Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around ()
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void open_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 790 of file game.h.

790 : int {
791 CHANGE_TAB,
792 QUIT,
793 FIRE, // Who knew, apparently you can do that in list_monsters
794 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 289 of file game.cpp.

289 :
291 scent_ptr( *this ),
294 m( *map_ptr ),
295 u( *u_ptr ),
296 scent( *scent_ptr ),
298 uquit( QUIT_NO ),
299 new_game( false ),
301 mostseen( 0 ),
304 next_npc_id( 1 ),
305 next_mission_id( 1 ),
309 seed( 0 ),
310 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
311{
319 world_generator = std::make_unique<worldfactory>();
320 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
321 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
322}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1044
pimpl< spell_events > spell_events_ptr
Definition: game.h:979
safe_mode_type safe_mode
Definition: game.h:1041
bool safe_mode_warning_logged
Definition: game.h:1055
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:973
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1089
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:999
event_bus & events()
Definition: game.cpp:2857
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:975
character_id next_npc_id
Definition: game.h:1057
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:977
void reset_light_level()
Definition: game.cpp:3701
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:978
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1046
pimpl< map > map_ptr
Definition: game.h:968
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1072
pimpl< live_view > liveview_ptr
Definition: game.h:970
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:976
pimpl< scent_map > scent_ptr
Definition: game.h:972
timed_event_manager & timed_events
Definition: game.h:987
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1084
int next_mission_id
Definition: game.h:1059
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1001
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:980
map & m
Definition: game.h:984
avatar & u
Definition: game.h:985
scent_map & scent
Definition: game.h:986
int user_action_counter
Definition: game.h:1078
live_view & liveview
Definition: game.h:971
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1081
pimpl< avatar > u_ptr
Definition: game.h:969
time_point remoteveh_cache_time
Definition: game.h:1065
static void achievement_attained(const achievement *a)
Definition: game.cpp:282
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 11895 of file game.cpp.

11896{
11897 //If player is sleeping, get a dream from a carried artifact
11898 //Don't need to check that player is sleeping here, that's done before calling
11899 std::list<item *> art_items = g->u.get_artifact_items();
11900 std::vector<item *> valid_arts;
11901 std::vector<std::vector<std::string>>
11902 valid_dreams; // Tracking separately so we only need to check its req once
11903 //Pull the list of dreams
11904 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
11905 for( auto &it : art_items ) {
11906 //Pick only the ones with an applicable dream
11907 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
11908 if( art && art->charge_req != ACR_NULL &&
11909 ( it->ammo_remaining() < it->ammo_capacity() ||
11910 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
11911 add_msg( m_debug, "Checking artifact %s", it->tname() );
11912 if( check_art_charge_req( *it ) ) {
11913 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11914 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
11915 add_msg( m_debug, "Adding met dream from %s", it->tname() );
11916 valid_arts.push_back( it );
11917 valid_dreams.push_back( art->dream_msg_met );
11918 }
11919 } else {
11920 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11921 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
11922 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
11923 valid_arts.push_back( it );
11924 valid_dreams.push_back( art->dream_msg_unmet );
11925 }
11926 }
11927 }
11928 }
11929 if( !valid_dreams.empty() ) {
11930 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
11931 const int selected = rng( 0, valid_arts.size() - 1 );
11932 auto it = valid_arts[selected];
11933 auto msg = random_entry( valid_dreams[selected] );
11934 const std::string &dream = string_format( _( msg ), it->tname() );
11935 add_msg( dream );
11936 } else {
11937 add_msg( m_debug, "Didn't have any dreams, sorry" );
11938 }
11939}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:264
std::unique_ptr< game > g
Definition: game.cpp:272
bool check_art_charge_req(item &it)
Definition: game.cpp:11598
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 11717 of file game.cpp.

11718{
11719 int net_str = 0;
11720 int net_dex = 0;
11721 int net_per = 0;
11722 int net_int = 0;
11723 int net_speed = 0;
11724
11725 for( auto &i : effects ) {
11726 switch( i ) {
11727 case AEP_STR_UP:
11728 net_str += 4;
11729 break;
11730 case AEP_DEX_UP:
11731 net_dex += 4;
11732 break;
11733 case AEP_PER_UP:
11734 net_per += 4;
11735 break;
11736 case AEP_INT_UP:
11737 net_int += 4;
11738 break;
11739 case AEP_ALL_UP:
11740 net_str += 2;
11741 net_dex += 2;
11742 net_per += 2;
11743 net_int += 2;
11744 break;
11745 case AEP_STR_DOWN:
11746 net_str -= 3;
11747 break;
11748 case AEP_DEX_DOWN:
11749 net_dex -= 3;
11750 break;
11751 case AEP_PER_DOWN:
11752 net_per -= 3;
11753 break;
11754 case AEP_INT_DOWN:
11755 net_int -= 3;
11756 break;
11757 case AEP_ALL_DOWN:
11758 net_str -= 2;
11759 net_dex -= 2;
11760 net_per -= 2;
11761 net_int -= 2;
11762 break;
11763
11764 case AEP_SPEED_UP:
11765 net_speed += 20;
11766 break;
11767 case AEP_SPEED_DOWN:
11768 net_speed -= 20;
11769 break;
11770
11771 case AEP_PBLUE:
11772 break; // No message
11773
11774 case AEP_SNAKES:
11775 add_msg( m_warning, _( "Your skin feels slithery." ) );
11776 break;
11777
11778 case AEP_INVISIBLE:
11779 add_msg( m_good, _( "You fade into invisibility!" ) );
11780 break;
11781
11782 case AEP_CLAIRVOYANCE:
11784 add_msg( m_good, _( "You can see through walls!" ) );
11785 break;
11786
11788 add_msg( m_good, _( "You can see through everything!" ) );
11789 break;
11790
11791 case AEP_STEALTH:
11792 add_msg( m_good, _( "Your steps stop making noise." ) );
11793 break;
11794
11795 case AEP_GLOW:
11796 add_msg( _( "A glow of light forms around you." ) );
11797 break;
11798
11799 case AEP_PSYSHIELD:
11800 add_msg( m_good, _( "Your mental state feels protected." ) );
11801 break;
11802
11804 add_msg( m_good, _( "You feel insulated." ) );
11805 break;
11806
11807 case AEP_CARRY_MORE:
11808 add_msg( m_good, _( "Your back feels strengthened." ) );
11809 break;
11810
11811 case AEP_FUN:
11812 add_msg( m_good, _( "You feel a pleasant tingle." ) );
11813 break;
11814
11815 case AEP_HUNGER:
11816 add_msg( m_warning, _( "You feel hungry." ) );
11817 break;
11818
11819 case AEP_THIRST:
11820 add_msg( m_warning, _( "You feel thirsty." ) );
11821 break;
11822
11823 case AEP_EVIL:
11824 add_msg( m_warning, _( "You feel an evil presence…" ) );
11825 break;
11826
11827 case AEP_SCHIZO:
11828 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
11829 break;
11830
11831 case AEP_RADIOACTIVE:
11832 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
11833 break;
11834
11835 case AEP_MUTAGENIC:
11836 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
11837 break;
11838
11839 case AEP_ATTENTION:
11840 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
11841 break;
11842
11843 case AEP_FORCE_TELEPORT:
11844 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
11845 break;
11846
11847 case AEP_MOVEMENT_NOISE:
11848 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
11849 break;
11850
11851 case AEP_BAD_WEATHER:
11852 add_msg( m_warning, _( "You feel storms coming." ) );
11853 break;
11854
11855 case AEP_SICK:
11856 add_msg( m_bad, _( "You feel unwell." ) );
11857 break;
11858
11859 case AEP_SMOKE:
11860 add_msg( m_warning, _( "A cloud of smoke appears." ) );
11861 break;
11862 default:
11863 //Suppress warnings
11864 break;
11865 }
11866 }
11867
11868 std::string stat_info;
11869 if( net_str != 0 ) {
11870 stat_info += string_format( _( "Str %s%d! " ),
11871 ( net_str > 0 ? "+" : "" ), net_str );
11872 }
11873 if( net_dex != 0 ) {
11874 stat_info += string_format( _( "Dex %s%d! " ),
11875 ( net_dex > 0 ? "+" : "" ), net_dex );
11876 }
11877 if( net_int != 0 ) {
11878 stat_info += string_format( _( "Int %s%d! " ),
11879 ( net_int > 0 ? "+" : "" ), net_int );
11880 }
11881 if( net_per != 0 ) {
11882 stat_info += string_format( _( "Per %s%d! " ),
11883 ( net_per > 0 ? "+" : "" ), net_per );
11884 }
11885
11886 if( !stat_info.empty() ) {
11887 add_msg( m_neutral, stat_info );
11888 }
11889
11890 if( net_speed != 0 ) {
11891 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
11892 }
11893}
@ m_good
Definition: enums.h:253
@ m_neutral
Definition: enums.h:260
@ m_info
Definition: enums.h:258
@ m_bad
Definition: enums.h:254
@ m_warning
Definition: enums.h:257
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3152 of file game.cpp.

3153{
3154 draw_callbacks.erase(
3155 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3156 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3157 return cbw.expired();
3158 } ),
3159 draw_callbacks.end()
3160 );
3161 draw_callbacks.emplace_back( cb );
3162 cb->added = true;
3164}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3117
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1968 of file game.cpp.

1969{
1970 follower_ids.insert( id );
1971 u.follower_ids.insert( id );
1972}
std::set< character_id > follower_ids
Definition: game.h:1060
std::set< character_id > follower_ids
Definition: player.h:615

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12051 of file game.cpp.

12052{
12053 return Creature_range( *this );
12054}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12056 of file game.cpp.

12057{
12058 return monster_range( *this );
12059}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12061 of file game.cpp.

12062{
12063 return npc_range( *this );
12064}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 11965 of file game.cpp.

11966{
11967 return get_npcs_if( [&]( const npc & guy ) {
11968 if( !guy.is_hallucination() ) {
11969 return guy.is_ally( g->u );
11970 } else {
11971 return false;
11972 }
11973 } );
11974}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:11988
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3260

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1956 of file game.cpp.

1957{
1958 int ret = next_mission_id;
1960 return ret;
1961}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3709 of file game.cpp.

3710{
3712 ++next_npc_id;
3713 return ret;
3714}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1761 of file game.cpp.

1762{
1763 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1764 vehicle *&v = veh.v;
1765 if( v->is_following ) {
1766 v->drive_to_local_target( m.getabs( u.pos() ), true );
1767 } else if( v->is_patrolling ) {
1768 v->autopilot_patrol();
1769 }
1770 }
1771}
const tripoint & pos() const override
Definition: character.cpp:714
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8249
VehicleList get_vehicles()
Definition: map.cpp:235
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1983
bool is_patrolling
Definition: vehicle.h:1984
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11384 of file game.cpp.

11385{
11386 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11387 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11388 return;
11389 }
11390 quicksave(); //Driving checks are handled by quicksave()
11391}
time_t last_save_timestamp
Definition: game.h:1062
void quicksave()
Definition: game.cpp:11339

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8380 of file game.cpp.

8381{
8382 static const std::string salvage_string = "salvage";
8383 if( u.controlling_vehicle ) {
8384 add_msg( m_info, _( "You can't butcher while driving!" ) );
8385 return;
8386 }
8387
8388 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8389 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8390 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8391 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8392
8393 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8394 if( m.has_flag( "SEALED", u.pos() ) ) {
8395 if( m.sees_some_items( u.pos(), u ) ) {
8396 add_msg( m_info, _( "You can't access the items here." ) );
8397 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8398 add_msg( m_info, no_corpse_msg );
8399 } else {
8400 add_msg( m_info, no_knife_msg );
8401 }
8402 return;
8403 }
8404
8405 const item *first_item_without_tools = nullptr;
8406 // Indices of relevant items
8407 std::vector<map_stack::iterator> corpses;
8408 std::vector<map_stack::iterator> disassembles;
8409 std::vector<map_stack::iterator> salvageables;
8410 map_stack items = m.i_at( u.pos() );
8411 const inventory &crafting_inv = u.crafting_inventory();
8412
8413 // TODO: Properly handle different material whitelists
8414 // TODO: Improve quality of this section
8415 auto salvage_filter = []( item it ) {
8416 const auto usable = it.get_usable_item( salvage_string );
8417 return usable != nullptr;
8418 };
8419
8420 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8421 int salvage_tool_index = INT_MIN;
8422 item *salvage_tool = nullptr;
8423 const salvage_actor *salvage_iuse = nullptr;
8424 if( !salvage_tools.empty() ) {
8425 salvage_tool = salvage_tools.front();
8426 salvage_tool_index = u.get_item_position( salvage_tool );
8427 item *usable = salvage_tool->get_usable_item( salvage_string );
8428 salvage_iuse = dynamic_cast<const salvage_actor *>(
8429 usable->get_use( salvage_string )->get_actor_ptr() );
8430 }
8431
8432 // Reserve capacity for each to hold entire item set if necessary to prevent
8433 // reallocations later on
8434 corpses.reserve( items.size() );
8435 salvageables.reserve( items.size() );
8436 disassembles.reserve( items.size() );
8437
8438 // Split into corpses, disassemble-able, and salvageable items
8439 // It's not much additional work to just generate a corpse list and
8440 // clear it later, but does make the splitting process nicer.
8441 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8442 if( it->is_corpse() ) {
8443 corpses.push_back( it );
8444 } else {
8445 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8446 salvageables.push_back( it );
8447 }
8448 if( crafting::can_disassemble( u, *it, crafting_inv ).success() ) {
8449 disassembles.push_back( it );
8450 } else if( !first_item_without_tools ) {
8451 first_item_without_tools = &*it;
8452 }
8453 }
8454 }
8455
8456 // Clear corpses if butcher and dissect factors are INT_MIN
8457 if( factor == INT_MIN && factorD == INT_MIN ) {
8458 corpses.clear();
8459 }
8460
8461 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8462 if( factor > INT_MIN || factorD > INT_MIN ) {
8463 add_msg( m_info, no_corpse_msg );
8464 } else {
8465 add_msg( m_info, no_knife_msg );
8466 }
8467
8468 if( first_item_without_tools ) {
8469 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8470 // Just for the "You need x to disassemble y" messages
8471 const auto ret = crafting::can_disassemble( u, *first_item_without_tools, crafting_inv );
8472 if( !ret.success() ) {
8473 add_msg( m_info, "%s", ret.c_str() );
8474 }
8475 }
8476 return;
8477 }
8478
8479 Creature *hostile_critter = is_hostile_very_close();
8480 if( hostile_critter != nullptr ) {
8481 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8482 hostile_critter->disp_name() ) ) {
8483 return;
8484 }
8485 }
8486
8487 // Magic indices for special butcher options
8488 enum : int {
8489 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8490 MULTIBUTCHER,
8491 MULTIDISASSEMBLE_ONE,
8492 MULTIDISASSEMBLE_ALL,
8493 NUM_BUTCHER_ACTIONS
8494 };
8495 // What are we butchering (i.e.. which vector to pick indices from)
8496 enum {
8497 BUTCHER_CORPSE,
8498 BUTCHER_DISASSEMBLE,
8499 BUTCHER_SALVAGE,
8500 BUTCHER_OTHER // For multisalvage etc.
8501 } butcher_select = BUTCHER_CORPSE;
8502 // Index to std::vector of iterators...
8503 int indexer_index = 0;
8504
8505 // Generate the indexed stacks so we can display them nicely
8506 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8507 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8508 // Always ask before cutting up/disassembly, but not before butchery
8509 size_t ret = 0;
8510 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8511 uilist kmenu;
8512 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8513
8514 size_t i = 0;
8515 // Add corpses, disassembleables, and salvagables to the UI
8516 add_corpses( kmenu, corpses, i );
8517 add_disassemblables( kmenu, disassembly_stacks, i );
8518 if( salvage_iuse && !salvageables.empty() ) {
8519 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8520 }
8521
8522 if( corpses.size() > 1 ) {
8523 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8524 }
8525 if( disassembles.size() > 1 ) {
8526 int time_to_disassemble = 0;
8527 int time_to_disassemble_all = 0;
8528 for( const auto &stack : disassembly_stacks ) {
8529 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8530 time_to_disassemble += time;
8531 time_to_disassemble_all += time * stack.second;
8532 }
8533
8534 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8535 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8536 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8537 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8538 }
8539 if( salvage_iuse && salvageables.size() > 1 ) {
8540 int time_to_salvage = 0;
8541 for( const auto &stack : salvage_stacks ) {
8542 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8543 }
8544
8545 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8546 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8547 }
8548
8549 kmenu.query();
8550
8551 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8552 return;
8553 }
8554
8555 ret = static_cast<size_t>( kmenu.ret );
8556 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8557 butcher_select = BUTCHER_OTHER;
8558 indexer_index = ret;
8559 } else if( ret < corpses.size() ) {
8560 butcher_select = BUTCHER_CORPSE;
8561 indexer_index = ret;
8562 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8563 butcher_select = BUTCHER_DISASSEMBLE;
8564 indexer_index = ret - corpses.size();
8565 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8566 butcher_select = BUTCHER_SALVAGE;
8567 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8568 } else {
8569 debugmsg( "Invalid butchery index: %d", ret );
8570 return;
8571 }
8572 }
8573
8574 if( !u.has_morale_to_craft() ) {
8575 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8576 add_msg( m_info,
8577 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8578 } else {
8579 add_msg( m_info,
8580 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8581 }
8582 return;
8583 }
8584 const auto helpers = u.get_crafting_helpers( 3 );
8585 for( const npc *np : helpers ) {
8586 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8587 }
8588 switch( butcher_select ) {
8589 case BUTCHER_OTHER:
8590 switch( indexer_index ) {
8591 case MULTISALVAGE:
8592 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8593 break;
8594 case MULTIBUTCHER:
8595 butcher_submenu( corpses );
8596 for( map_stack::iterator &it : corpses ) {
8597 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8598 }
8599 break;
8600 case MULTIDISASSEMBLE_ONE:
8601 crafting::disassemble_all( u, false );
8602 break;
8603 case MULTIDISASSEMBLE_ALL:
8605 break;
8606 default:
8607 debugmsg( "Invalid butchery type: %d", indexer_index );
8608 return;
8609 }
8610 break;
8611 case BUTCHER_CORPSE: {
8612 butcher_submenu( corpses, indexer_index );
8613 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8614 }
8615 break;
8616 case BUTCHER_DISASSEMBLE: {
8617 // Pick index of first item in the disassembly stack
8618 item *const target = &*disassembly_stacks[indexer_index].first;
8620 }
8621 break;
8622 case BUTCHER_SALVAGE: {
8623 if( !salvage_iuse || !salvage_tool ) {
8624 debugmsg( "null salve_iuse or salvage_tool" );
8625 } else {
8626 // Pick index of first item in the salvage stack
8627 item *const target = &*salvage_stacks[indexer_index].first;
8628 item_location item_loc( map_cursor( u.pos() ), target );
8629 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8630 }
8631 }
8632 break;
8633 }
8634}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:228
player_activity activity
Definition: character.h:1516
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2407
bool has_morale_to_craft() const
Definition: crafting.cpp:335
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:553
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9189
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3723
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:176
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7833
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7807
Definition: map.h:105
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2290
map_stack i_at(const tripoint &p)
Definition: map.cpp:4071
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4717
std::vector< item_location > targets
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2308
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:962
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:942
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8230
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8188
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8209
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8141
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8176
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:838
ret_val< bool > can_disassemble(const Character &who, const item &obj, const inventory &inv)
Check if character can disassemble an item using the given crafting inventory.
Definition: crafting.cpp:1875
bool disassemble(avatar &you)
Prompt for an item to disassemble, then start activity.
Definition: crafting.cpp:2074
bool disassemble_all(avatar &you, bool recursively)
Start an activity to disassemble all items in avatar's square.
Definition: crafting.cpp:2085
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:314
string_id< quality > quality_id
Definition: type_id.h:181

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), crafting::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, crafting::disassemble(), crafting::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1342 of file game.cpp.

1343{
1344 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1346 return;
1347 }
1348 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1349 const int light_sight_range = u.sight_range( g_light_level );
1350 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1351
1352 // The maximal offset will leave at least this many tiles
1353 // between the PC and the edge of the main window.
1354 static const int border_range = 2;
1355 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1356 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1357
1358 // velocity at or below this results in no offset at all
1359 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1360 // velocity at or above this results in maximal offset
1361 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1363 float velocity = veh->velocity;
1364 rl_vec2d offset = veh->move_vec();
1365 if( !veh->skidding && veh->player_in_control( u ) &&
1366 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1367 // Use the cruise controlled velocity, but only if
1368 // it is not too different from the actual velocity.
1369 // The actual velocity changes too often (see above slowdown).
1370 // Using it makes would make the offset change far too often.
1371 offset = veh->face_vec();
1372 velocity = veh->cruise_velocity;
1373 }
1374 float rel_offset;
1375 if( std::fabs( velocity ) < min_offset_vel ) {
1376 rel_offset = 0;
1377 } else if( std::fabs( velocity ) > max_offset_vel ) {
1378 rel_offset = ( velocity > 0 ) ? 1 : -1;
1379 } else {
1380 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1381 }
1382 // Squeeze into the corners, by making the offset vector longer,
1383 // the PC is still in view as long as both offset.x and
1384 // offset.y are <= 1
1385 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1386 offset.y /= std::fabs( offset.x );
1387 offset.x = ( offset.x > 0 ) ? +1 : -1;
1388 } else if( std::fabs( offset.y ) > 0.2 ) {
1389 offset.x /= std::fabs( offset.y );
1390 offset.y = offset.y > 0 ? +1 : -1;
1391 }
1392 offset.x *= rel_offset;
1393 offset.y *= rel_offset;
1394 offset.x *= max_offset.x;
1395 offset.y *= max_offset.y;
1396 // [ ----@---- ] sight=6
1397 // [ --@------ ] offset=2
1398 // [ -@------# ] offset=3
1399 // can see sights square in every direction, total visible area is
1400 // (2*sight+1)x(2*sight+1), but the window is only
1401 // getmaxx(w_terrain) x getmaxy(w_terrain)
1402 // The area outside of the window is maxoff (sight-getmax/2).
1403 // If that value is <= 0, the whole visible area fits the window.
1404 // don't apply the view offset at all.
1405 // If the offset is > maxoff, only apply at most maxoff, everything
1406 // above leads to invisible area in front of the car.
1407 // It will display (getmax/2+offset) squares in one direction and
1408 // (getmax/2-offset) in the opposite direction (centered on the PC).
1409 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1410 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1411 if( maxoff.x <= 0 ) {
1412 offset.x = 0;
1413 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1414 offset.x = maxoff.x;
1415 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1416 offset.x = -maxoff.x;
1417 }
1418 if( maxoff.y <= 0 ) {
1419 offset.y = 0;
1420 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1421 offset.y = maxoff.y;
1422 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1423 offset.y = -maxoff.y;
1424 }
1425
1426 // Turn the offset into a vector that increments the offset toward the desired position
1427 // instead of setting it there instantly, should smooth out jerkiness.
1428 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1429
1430 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1431 ( offset_difference.y < 0 ) ? -1 : 1 );
1432 // Shift the current offset in the direction of the calculated offset by one tile
1433 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1434 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1435 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1436 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1437 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1438
1439 set_driving_view_offset( point( offset.x, offset.y ) );
1440}
int posz() const override
Definition: character.h:785
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:719
point driving_view_offset
Definition: game.h:1018
catacurses::window w_terrain
Definition: game.h:1008
void set_driving_view_offset(const point &p)
Definition: game.cpp:1699
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3695
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1999
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1918
int cruise_velocity
Definition: vehicle.h:1920
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1324
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1800 of file game.cpp.

1801{
1803 if( u.has_distant_destination() ) {
1804 if( cancel_auto_move( u, text ) ) {
1805 return true;
1806 } else {
1808 return false;
1809 }
1810 }
1812 return false;
1813 }
1814 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1815 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1817
1818 const auto &action = query_popup()
1819 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1820 .message( force_uc ?
1821 pgettext( "cancel_activity_or_ignore_query",
1822 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1823 pgettext( "cancel_activity_or_ignore_query",
1824 "<color_light_red>%s %s</color>" ),
1825 text, u.activity.get_stop_phrase() )
1826 .option( "YES", allow_key )
1827 .option( "NO", allow_key )
1828 .option( "IGNORE", allow_key )
1829 .query()
1830 .action;
1831
1832 if( action == "YES" ) {
1834 return true;
1835 }
1836 if( action == "IGNORE" ) {
1838 for( auto &activity : u.backlog ) {
1839 activity.ignore_distraction( type );
1840 }
1841 }
1842
1845
1846 return false;
1847}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9232
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1517
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1787
void redraw()
Definition: ui_manager.cpp:285
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1849 of file game.cpp.

1850{
1852 if( u.has_distant_destination() ) {
1853 if( cancel_auto_move( u, text ) ) {
1854 return true;
1855 } else {
1857 return false;
1858 }
1859 }
1860 if( !u.activity ) {
1861 return false;
1862 }
1863 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1867 return true;
1868 }
1869 return false;
1870}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9264

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1773 of file game.cpp.

1775{
1776 //spawn the corpse, rotten by a part of the duration
1778 catch_duration ) ) );
1779 if( u.sees( pos ) ) {
1780 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1781 }
1782 //quietly kill the caught
1783 fish->no_corpse_quiet = true;
1784 fish->die( p );
1785}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:507
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4216
bool no_corpse_quiet
Definition: monster.h:485
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2268
const mtype * type
Definition: monster.h:481
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:3973
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 394 of file npctalk.cpp.

395{
396 int volume = g->u.get_shout_volume();
397
398 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
399 // TODO: Get rid of the z-level check when z-level vision gets "better"
400 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
401 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
402 } );
403 const int available_count = available.size();
404 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
405 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
406 } );
407 const int follower_count = followers.size();
408 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
409 return guy.mission == NPC_MISSION_GUARD_ALLY &&
410 guy.companion_mission_role_id != "FACTION_CAMP" &&
411 guy.can_hear( u.pos(), volume );
412 } );
413 const int guard_count = guards.size();
414
415 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
416 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
417 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
418 return;
419 }
420 std::vector<vehicle *> animal_vehicles;
421 std::vector<vehicle *> following_vehicles;
422 std::vector<vehicle *> magic_vehicles;
423 std::vector<vehicle *> magic_following_vehicles;
424 for( auto &veh : g->m.get_vehicles() ) {
425 auto &v = veh.v;
426 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
427 animal_vehicles.push_back( v );
428 if( v->is_following ) {
429 following_vehicles.push_back( v );
430 }
431 }
432 if( v->magic ) {
433 for( const vpart_reference &vp : v->get_all_parts() ) {
434 const vpart_info &vpi = vp.info();
435 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
436 magic_vehicles.push_back( v );
437 if( v->is_following ) {
438 magic_following_vehicles.push_back( v );
439 }
440 break;
441 }
442 }
443 }
444 }
445
446 uilist nmenu;
447 nmenu.text = std::string( _( "What do you want to do?" ) );
448
449 if( !available.empty() ) {
450 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
451 string_format( _( "Talk to %s" ), available.front()->name ) :
452 _( "Talk to…" )
453 );
454 }
455 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
456 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
457 if( !animal_vehicles.empty() ) {
459 _( "Whistle at your animals pulling vehicles to follow you." ) );
460 }
461 if( !magic_vehicles.empty() ) {
463 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
464 }
465 if( !magic_following_vehicles.empty() ) {
467 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
468 }
469 if( !following_vehicles.empty() ) {
471 _( "Whistle at your animals pulling vehicles to stop following you." ) );
472 }
473 if( !guards.empty() ) {
474 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
475 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
476 _( "Tell someone to follow…" )
477 );
478 }
479 if( !followers.empty() ) {
480 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
481 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
482 _( "Tell someone to guard…" )
483 );
484 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
485 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
486 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
487 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
488 _( "Tell everyone on your team to prepare for danger" ) );
489 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
490 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
491 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
492 }
493 std::string message;
494 std::string yell_msg;
495 bool is_order = true;
496 nmenu.query();
497
498 if( nmenu.ret < 0 ) {
499 return;
500 }
501
502 switch( nmenu.ret ) {
503 case NPC_CHAT_TALK: {
504 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
505 if( npcselect < 0 ) {
506 return;
507 }
508 available[npcselect]->talk_to_u();
509 break;
510 }
511 case NPC_CHAT_YELL:
512 is_order = false;
513 message = _( "loudly." );
514 break;
515 case NPC_CHAT_SENTENCE: {
516 std::string popupdesc = _( "Enter a sentence to yell" );
518 popup.title( _( "Yell a sentence" ) )
519 .width( 64 )
520 .description( popupdesc )
521 .identifier( "sentence" )
522 .max_length( 128 )
523 .query();
524 yell_msg = popup.text();
525 is_order = false;
526 break;
527 }
528 case NPC_CHAT_GUARD: {
529 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
530 if( npcselect < 0 ) {
531 return;
532 }
533 if( npcselect == follower_count ) {
534 for( npc *them : followers ) {
536 }
537 yell_msg = _( "Everyone guard here!" );
538 } else {
539 talk_function::assign_guard( *followers[npcselect] );
540 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
541 }
542 break;
543 }
544 case NPC_CHAT_FOLLOW: {
545 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
546 if( npcselect < 0 ) {
547 return;
548 }
549 if( npcselect == guard_count ) {
550 for( npc *them : guards ) {
552 }
553 yell_msg = _( "Everyone follow me!" );
554 } else {
555 talk_function::stop_guard( *guards[npcselect] );
556 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
557 }
558 break;
559 }
560 case NPC_CHAT_AWAKE:
561 for( npc *them : followers ) {
562 talk_function::wake_up( *them );
563 }
564 yell_msg = _( "Stay awake!" );
565 break;
566 case NPC_CHAT_MOUNT:
567 for( npc *them : followers ) {
568 if( them->has_effect( effect_riding ) ) {
569 continue;
570 }
572 }
573 yell_msg = _( "Mount up!" );
574 break;
576 for( npc *them : followers ) {
577 if( them->has_effect( effect_riding ) ) {
578 them->npc_dismount();
579 }
580 }
581 yell_msg = _( "Dismount!" );
582 break;
583 case NPC_CHAT_DANGER:
584 for( npc *them : followers ) {
585 them->rules.set_danger_overrides();
586 }
587 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
588 "and don't open any doors." );
589 break;
591 for( npc *p : followers ) {
593 }
594 yell_msg = _( "As you were." );
595 break;
596 case NPC_CHAT_ORDERS:
597 npc_temp_orders_menu( followers );
598 break;
601 break;
604 break;
607 break;
610 break;
611 default:
612 return;
613 }
614
615 if( !yell_msg.empty() ) {
616 message = string_format( "\"%s\"", yell_msg );
617 }
618 if( !message.empty() ) {
619 add_msg( _( "You yell %s" ), message );
620 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
621 }
622
623 u.moves -= 100;
624}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:546
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7729
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1987
bool is_following() const
Definition: npc.cpp:2018
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:403
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4126
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:220
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:377
static void tell_veh_stop_following()
Definition: npctalk.cpp:340
static void assign_veh_to_follow()
Definition: npctalk.cpp:351
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:252
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:214
@ NPC_CHAT_YELL
Definition: npctalk.cpp:195
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:198
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:197
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:201
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:203
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:196
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:210
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:202
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:199
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:212
@ NPC_CHAT_TALK
Definition: npctalk.cpp:194
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:213
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:361
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 348 of file game.cpp.

349{
350 auto &tree = world_generator->get_mod_manager().get_tree();
351
352 // deduplicated list of mods to check
353 std::set<mod_id> check( opts.begin(), opts.end() );
354
355 // if no specific mods specified check all non-obsolete mods
356 if( check.empty() ) {
357 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
358 if( !e->obsolete ) {
359 check.emplace( e );
360 }
361 }
362 }
363
364 if( check.empty() ) {
365 world_generator->set_active_world( nullptr );
366 world_generator->init();
367 const std::vector<mod_id> mods_empty;
368 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
369 world_generator->set_active_world( test_world );
370
371 // if no loadable mods then test core data only
372 try {
375 } catch( const std::exception &err ) {
376 std::cerr << "Error loading data from json: " << err.what() << std::endl;
377 }
378
379 std::string world_name = world_generator->active_world->world_name;
380 world_generator->delete_world( world_name, true );
381
384 }
385
386 for( const auto &e : check ) {
387 world_generator->set_active_world( nullptr );
388 world_generator->init();
389 const std::vector<mod_id> mods_empty;
390 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
391 if( !test_world ) {
392 std::cerr << "Failed to generate test world." << std::endl;
393 return false;
394 }
395 world_generator->set_active_world( test_world );
396
397 if( !e.is_valid() ) {
398 std::cerr << "Unknown mod: " << e.str() << std::endl;
399 return false;
400 }
401
402 const MOD_INFORMATION &mod = *e;
403
404 if( !tree.is_available( mod.ident ) ) {
405 std::cerr << "Missing dependencies: " << mod.name() << "\n"
406 << tree.get_node( mod.ident )->s_errors() << std::endl;
407 return false;
408 }
409
410 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
411
412 try {
414
415 // Load any dependencies
416 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
417 load_data_from_dir( dep->path, dep->ident.str(), ui );
418 }
419
420 // Load mod itself
421 load_data_from_dir( mod.path, mod.ident.str(), ui );
423 } catch( const std::exception &err ) {
424 std::cerr << "Error loading data: " << err.what() << std::endl;
425 }
426
427 std::string world_name = world_generator->active_world->world_name;
428 world_generator->delete_world( world_name, true );
429
432 }
433 return true;
434}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:633
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:114
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:450
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:441
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6104 of file game.cpp.

6105{
6106 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6107}
static zone_manager & get_manager()
Definition: clzones.cpp:126
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 8636 of file game.cpp.

8637{
8638 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
8639 // Already warned player since safe_mode_warning_logged is set.
8640 return false;
8641 }
8642
8643 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
8644 if( !msg_ignore.empty() ) {
8645 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
8646 // Operate on a wide-char basis to prevent corrupted multi-byte string
8647 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
8648 msg_ignore = wstr_to_utf8( msg_ignore_wide );
8649 }
8650
8652 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
8653 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
8655 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
8656 } else {
8658 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
8659 }
8661 return false;
8662 }
8663 if( safe_mode != SAFE_MODE_STOP ) {
8664 return true;
8665 }
8666 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
8667 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
8668 return true;
8669 }
8670 // Monsters around and we don't want to run
8671 std::string spotted_creature_name;
8672 const monster_visible_info &mon_visible = u.get_mon_visible();
8673 const auto &new_seen_mon = mon_visible.new_seen_mon;
8674
8675 if( new_seen_mon.empty() ) {
8676 // naming consistent with code in game::mon_info
8677 spotted_creature_name = _( "a survivor" );
8679 } else {
8680 spotted_creature_name = new_seen_mon.back()->name();
8681 get_safemode().lastmon_whitelist = spotted_creature_name;
8682 }
8683
8684 std::string whitelist;
8685 if( !get_safemode().empty() ) {
8686 whitelist = string_format( _( " or %s to whitelist the monster" ),
8688 }
8689
8690 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
8692 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
8693 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
8695 return false;
8696}
std::string press_x(action_id act)
Definition: action.cpp:452
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1179
int get_int_base() const override
Definition: avatar.cpp:1006
monster_visible_info & get_mon_visible()
Definition: avatar.h:213
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:281
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:286
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:40

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6099 of file game.cpp.

6100{
6101 return zone_manager::get_manager().has( type, m.getabs( where ) );
6102}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1038 of file game.cpp.

1039{
1040 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1041 // Put (non-hallucinations) into the overmap so they are not lost.
1042 for( monster &critter : all_monsters() ) {
1043 despawn_monster( critter );
1044 }
1045 // Reset NPC factions and disposition
1047 // Save the factions', missions and set the NPC's overmap coordinates
1048 // Npcs are saved in the overmap.
1049 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1050 // save artifacts.
1052
1053 // and the overmap, and the local map.
1054 save_maps(); //Omap also contains the npcs who need to be saved.
1055 }
1056
1057 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1058 std::vector<std::string> vRip;
1059
1060 int iMaxWidth = 0;
1061 int iNameLine = 0;
1062 int iInfoLine = 0;
1063
1066 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1067 vRip.emplace_back( " _______ ___" );
1068 vRip.emplace_back( " < `/ |" );
1069 vRip.emplace_back( " > _ _ (" );
1070 vRip.emplace_back( " | |_) | |_) |" );
1071 vRip.emplace_back( " | | \\ | | |" );
1072 vRip.emplace_back( " ______.__%_| |_________ __" );
1073 vRip.emplace_back( " _/ \\| |" );
1074 iNameLine = vRip.size();
1075 vRip.emplace_back( "| <" );
1076 vRip.emplace_back( "| |" );
1077 iMaxWidth = utf8_width( vRip.back() );
1078 vRip.emplace_back( "| |" );
1079 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1080 vRip.emplace_back( " | |" );
1081 iInfoLine = vRip.size();
1082 vRip.emplace_back( " | |" );
1083 vRip.emplace_back( " | <" );
1084 vRip.emplace_back( " | |" );
1085 vRip.emplace_back( " | _ |" );
1086 vRip.emplace_back( " |__/ |" );
1087 vRip.emplace_back( " % / `--. |%" );
1088 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1089 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1090 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1091 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1092
1093 } else {
1094 vRip.emplace_back( " _______ ___" );
1095 vRip.emplace_back( " | \\/ |" );
1096 vRip.emplace_back( " | |" );
1097 vRip.emplace_back( " | |" );
1098 iInfoLine = vRip.size();
1099 vRip.emplace_back( " | |" );
1100 vRip.emplace_back( " | |" );
1101 vRip.emplace_back( " | |" );
1102 vRip.emplace_back( " | |" );
1103 vRip.emplace_back( " | <" );
1104 vRip.emplace_back( " | _ |" );
1105 vRip.emplace_back( " |__/ |" );
1106 vRip.emplace_back( " ______.__%_| |__________ _" );
1107 vRip.emplace_back( " _/ \\| \\" );
1108 iNameLine = vRip.size();
1109 vRip.emplace_back( "| <" );
1110 vRip.emplace_back( "| |" );
1111 iMaxWidth = utf8_width( vRip.back() );
1112 vRip.emplace_back( "| |" );
1113 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1114 vRip.emplace_back( " % / `_-. _ |%" );
1115 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1116 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1117 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1118 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1119 }
1120 } else {
1121 vRip.emplace_back( R"( _________ ____ )" );
1122 vRip.emplace_back( R"( _/ `/ \_ )" );
1123 vRip.emplace_back( R"( _/ _ _ \_. )" );
1124 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1125 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1126 vRip.emplace_back( R"( _/ \_ )" );
1127 vRip.emplace_back( R"(| |)" );
1128 iNameLine = vRip.size();
1129 vRip.emplace_back( R"( ) < )" );
1130 vRip.emplace_back( R"(| |)" );
1131 vRip.emplace_back( R"(| |)" );
1132 vRip.emplace_back( R"(| _ |)" );
1133 vRip.emplace_back( R"(|__/ |)" );
1134 iMaxWidth = utf8_width( vRip.back() );
1135 vRip.emplace_back( R"( / `--. |)" );
1136 vRip.emplace_back( R"(| ( )" );
1137 iInfoLine = vRip.size();
1138 vRip.emplace_back( R"(| |)" );
1139 vRip.emplace_back( R"(| |)" );
1140 vRip.emplace_back( R"(| % . |)" );
1141 vRip.emplace_back( R"(| @` %% |)" );
1142 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1143 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1144 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1145 }
1146
1147 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1148 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1149
1151 point( iOffsetX, iOffsetY ) );
1152 draw_border( w_rip );
1153
1154 sfx::do_player_death_hurt( g->u, true );
1159
1160 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1161 size_t iX = 0;
1162 const char *str = vRip[iY].data();
1163 for( int slen = vRip[iY].size(); slen > 0; ) {
1164 const uint32_t cTemp = UTF8_getch( &str, &slen );
1165 if( cTemp != U' ' ) {
1166 nc_color ncColor = c_light_gray;
1167
1168 if( cTemp == U'%' ) {
1169 ncColor = c_green;
1170
1171 } else if( cTemp == U'_' || cTemp == U'|' ) {
1172 ncColor = c_white;
1173
1174 } else if( cTemp == U'@' ) {
1175 ncColor = c_brown;
1176
1177 } else if( cTemp == U'*' ) {
1178 ncColor = c_red;
1179 }
1180
1181 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1182 cTemp );
1183 }
1184 iX += mk_wcwidth( cTemp );
1185 }
1186 }
1187
1188 std::string sTemp;
1189
1190 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1191
1193 const int minutes = to_minutes<int>( survived ) % 60;
1194 const int hours = to_hours<int>( survived ) % 24;
1195 const int days = to_days<int>( survived );
1196
1197 if( days > 0 ) {
1198 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1199 } else if( hours > 0 ) {
1200 sTemp = string_format( "%dh %dm", hours, minutes );
1201 } else {
1202 sTemp = string_format( "%dm", minutes );
1203 }
1204
1205 center_print( w_rip, iInfoLine++, c_white, sTemp );
1206
1207 const int iTotalKills = get_kill_tracker().monster_kill_count();
1208
1209 sTemp = _( "Kills:" );
1210 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1211 ( sTemp + " " ) );
1212 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1213
1214 sTemp = _( "In memory of:" );
1215 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1217 sTemp );
1218
1219 sTemp = u.name;
1220 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1221 sTemp );
1222
1223 sTemp = _( "Last Words:" );
1224 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1226 sTemp );
1227
1228 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1229 std::string sLastWords = string_input_popup()
1230 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1231 .max_length( iMaxWidth - 4 - 1 )
1232 .query_string();
1233 death_screen();
1234 const bool is_suicide = uquit == QUIT_SUICIDE;
1235 events().send<event_type::game_over>( is_suicide, sLastWords );
1236 // Struck the save_player_data here to forestall Weirdness
1237 std::string char_filename = generate_memorial_filename( u.name );
1238 move_save_to_graveyard( char_filename );
1239 write_memorial_file( char_filename, sLastWords );
1240 memorial().clear();
1241 std::vector<std::string> characters = list_active_characters();
1242 // remove current player from the active characters list, as they are dead
1243 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1244 characters.end(), u.name );
1245 if( curchar != characters.end() ) {
1246 characters.erase( curchar );
1247 }
1248
1249 if( characters.empty() ) {
1250 bool queryDelete = false;
1251 bool queryReset = false;
1252
1253 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1254 bool decided = false;
1255 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1256 "will not all reset when starting a new character in an "
1257 "already-played world. This can lead to some strange "
1258 "behavior.\n\n"
1259 "Are you sure you wish to keep this world?"
1260 );
1261
1262 while( !decided ) {
1263 uilist smenu;
1264 smenu.allow_cancel = false;
1265 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1266 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1267 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1268 smenu.query();
1269
1270 switch( smenu.ret ) {
1271 case 0:
1272 queryReset = true;
1273 decided = true;
1274 break;
1275 case 1:
1276 queryDelete = true;
1277 decided = true;
1278 break;
1279 case 2:
1280 decided = query_yn( buffer );
1281 break;
1282 }
1283 }
1284 }
1285
1286 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1287 world_generator->delete_world( world_generator->active_world->world_name, true );
1288
1289 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1290 world_generator->delete_world( world_generator->active_world->world_name, false );
1291 }
1292 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1293 std::string tmpmessage;
1294 for( auto &character : characters ) {
1295 tmpmessage += "\n ";
1296 tmpmessage += character;
1297 }
1298 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1299 }
1300 if( gamemode ) {
1301 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1302 }
1303 }
1304
1305 //Reset any offset due to driving
1307
1308 //clear all sound channels
1314
1315 MAPBUFFER.reset();
1317
1318#if defined(__ANDROID__)
1319 quick_shortcuts_map.clear();
1320#endif
1321 return true;
1322}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1504
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2554
bool save_maps()
Definition: game.cpp:2818
std::unique_ptr< special_game > gamemode
Definition: game.h:1076
void death_screen()
Definition: game.cpp:2504
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12056
bool save_factions_missions_npcs()
Definition: game.cpp:2804
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11081
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:976
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:2917
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:2902
bool save_artifacts()
Definition: game.cpp:2812
memorial_logger & memorial()
Definition: game.cpp:2867
void reset_npc_dispositions()
Definition: game.cpp:2776
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1011
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4171 of file game.cpp.

4172{
4173 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4174 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4175 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4176
4177 bool npc_is_dead = false;
4178 // can't use all_npcs as that does not include dead ones
4179 for( const auto &n : active_npc ) {
4180 if( n->is_dead() ) {
4181 n->die( nullptr ); // make sure this has been called to create corpses etc.
4182 npc_is_dead = true;
4183 }
4184 }
4185
4186 if( monster_is_dead ) {
4187 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4188 critter_tracker->remove_dead();
4189 }
4190
4191 if( npc_is_dead ) {
4192 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4193 if( ( *it )->is_dead() ) {
4194 remove_npc_follower( ( *it )->getID() );
4195 overmap_buffer.remove_npc( ( *it )->getID() );
4196 it = active_npc.erase( it );
4197 } else {
4198 it++;
4199 }
4200 }
4201 }
4202
4203 critter_died = false;
4204}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1974
pimpl< Creature_tracker > critter_tracker
Definition: game.h:994
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1058
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1070
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 4845 of file game.cpp.

4846{
4847 critter_tracker->clear();
4848}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5259 of file game.cpp.

5260{
5261 static const itype_id fuel_type_animal( "animal" );
5262 int veh_part = -1;
5263 vehicle *veh = remoteveh();
5264 if( veh == nullptr ) {
5265 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5266 veh = &vp->vehicle();
5267 veh_part = vp->part_index();
5268 }
5269 }
5270 if( veh != nullptr && veh->player_in_control( u ) &&
5271 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5272 veh->use_controls( u.pos() );
5273 } else if( veh && veh->player_in_control( u ) &&
5274 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5275 u.controlling_vehicle = false;
5276 add_msg( m_info, _( "You let go of the reins." ) );
5277 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5278 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5279 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5280 u.in_vehicle ) {
5281 if( u.has_trait( trait_WAYFARER ) ) {
5282 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5283 return;
5284 }
5285 if( !veh->interact_vehicle_locked() ) {
5286 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5287 return;
5288 }
5289 if( veh->engine_on ) {
5290 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5291 return;
5292 }
5293 u.controlling_vehicle = true;
5294 add_msg( _( "You take control of the %s." ), veh->name );
5295 } else {
5296 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5297 return;
5298 }
5299 veh->start_engines( true );
5300 }
5301 } else { // Start looking for nearby vehicle controls.
5302 int num_valid_controls = 0;
5303 cata::optional<tripoint> vehicle_position;
5304 cata::optional<vpart_reference> vehicle_controls;
5305 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5306 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5307 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5308 if( controls ) {
5309 num_valid_controls++;
5310 vehicle_position = elem;
5311 vehicle_controls = controls;
5312 }
5313 }
5314 }
5315 if( num_valid_controls < 1 ) {
5316 add_msg( _( "No vehicle controls found." ) );
5317 return;
5318 } else if( num_valid_controls > 1 ) {
5319 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5320 if( !vehicle_position ) {
5321 return;
5322 }
5323 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5324 if( vp ) {
5325 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5326 if( !vehicle_controls ) {
5327 add_msg( _( "The vehicle doesn't have controls there." ) );
5328 return;
5329 }
5330 } else {
5331 add_msg( _( "No vehicle there." ) );
5332 return;
5333 }
5334 }
5335 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5336 if( vehicle_controls ) {
5337 veh = &vehicle_controls->vehicle();
5338 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5339 return;
5340 }
5341 veh->use_controls( *vehicle_position );
5342 //May be folded up (destroyed), so need to re-get it
5343 veh = g->remoteveh();
5344 }
5345 }
5346 if( veh ) {
5347 // If we reached here, we gained control of a vehicle.
5348 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5349 for( const tripoint &target : veh->get_points() ) {
5350 u.clear_memorized_tile( m.getabs( target ) );
5351 }
5352 veh->is_following = false;
5353 veh->is_patrolling = false;
5354 veh->autopilot_on = false;
5355 veh->is_autodriving = false;
5356 }
5357}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1019
bool in_vehicle
Definition: character.h:1511
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:165
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2340
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8593
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1006
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:90
bool engine_on
Definition: vehicle.h:1989
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6758
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4377
std::string name
Definition: vehicle.h:1849
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1997
bool is_autodriving
Definition: vehicle.h:1982
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3054 of file game.cpp.

3055{
3057 if( !ui ) {
3058 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3059 ui->on_redraw( []( const ui_adaptor & ) {
3060 g->draw();
3061 } );
3062 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3063 // remove some space for the sidebar, this is the maximal space
3064 // (using standard font) that the terrain window can have
3065 const int sidebar_left = panel_manager::get_manager().get_width_left();
3066 const int sidebar_right = panel_manager::get_manager().get_width_right();
3067
3069 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3072
3073 /**
3074 * In tiles mode w_terrain can have a different font (with a different
3075 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3076 * might have a different dimension then the normal font used everywhere else.
3077 *
3078 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3079 * be displayed in w_terrain (using it's specific tile dimension), not
3080 * including partially drawn squares at the right/bottom. You should
3081 * use it whenever you want to draw specific squares in that window or to
3082 * determine whether a specific square is draw on screen (or outside the screen
3083 * and needs scrolling).
3084 *
3085 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3086 * w_terrain in the standard font dimension (the font that everything else uses).
3087 * You usually don't have to use it, expect for positioning of windows,
3088 * because the window positions use the standard font dimension.
3089 *
3090 * The code here calculates size available for w_terrain, caps it at
3091 * max_view_size (the maximal view range than any character can have at
3092 * any time).
3093 * It is stored in TERRAIN_WINDOW_*.
3094 */
3096
3097 // Position of the player in the terrain window, it is always in the center
3100
3102 point( sidebar_left, 0 ) );
3103
3104 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3106
3107 // need to init in order to avoid crash. gets updated by the panel code.
3109
3110 ui.position_from_window( catacurses::stdscr );
3111 } );
3112 ui->mark_resize();
3113 }
3114 return ui;
3115}
catacurses::window w_pixel_minimap
Definition: game.h:1012
catacurses::window w_minimap_ptr
Definition: game.h:1049
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1095
catacurses::window w_minimap
Definition: game.h:1011
catacurses::window w_terrain_ptr
Definition: game.h:1048
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2294
int get_width_left()
Definition: panels.cpp:2302
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 981 of file game.cpp.

982{
983 if( !get_option<bool>( "STATIC_NPC" ) ||
984 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
985 return; //Do not generate a starting npc.
986 }
987
988 //We don't want more than one starting npc per starting location
989 const int radius = 1;
990 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
991 return; //There is already an NPC in this starting location
992 }
993
994 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
995 tmp->normalize();
996 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
997 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
999 tmp->form_opinion( u );
1000 tmp->set_attitude( NPCATT_NULL );
1001 //This sets the NPC mission. This NPC remains in the starting location.
1002 tmp->mission = NPC_MISSION_SHELTER;
1003 tmp->chatbin.first_topic = "TALK_SHELTER";
1004 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
1005 tmp->set_fac( faction_id( "no_faction" ) );
1006 //One random starting NPC mission
1007 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
1008 tmp->getID() ) );
1009}
int get_levy() const
Definition: game.cpp:11946
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:11941
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4650 of file game.cpp.

4651{
4652 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4653 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4654 return nullptr;
4655 }
4656 // if we wanted to check for an NPC / player / avatar,
4657 // there is sometimes a monster AND an NPC/player there at the same time.
4658 // because the NPC/player etc may be riding that monster.
4659 // so only return the monster if we were actually looking for a monster.
4660 // otherwise, keep looking for the rider.
4661 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4662 // which is ok for the occasions where that happens.
4663 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4664 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4665 std::is_same<T, const Creature>::value ) ) {
4666 return dynamic_cast<T *>( mon_ptr.get() );
4667 }
4668 }
4669 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4670 if( p == u.pos() ) {
4671 return dynamic_cast<T *>( &u );
4672 }
4673 }
4674 for( auto &cur_npc : active_npc ) {
4675 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4676 return dynamic_cast<T *>( cur_npc.get() );
4677 }
4678 }
4679 return nullptr;
4680}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4683 of file game.cpp.

4684{
4685 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4686}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4729 of file game.cpp.

4730{
4731 if( id == u.getID() ) {
4732 // player is always alive, therefore no is-dead check
4733 return dynamic_cast<T *>( &u );
4734 }
4735 return find_npc( id );
4736}
character_id getID() const
Definition: character.cpp:477
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1963

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2504 of file game.cpp.

2505{
2506 gamemode->game_over();
2510 follower_ids.clear();
2512}
stats_tracker & stats()
Definition: game.cpp:2862
void disp_NPC_epilogues()
Definition: game.cpp:2941
void display_faction_epilogues()
Definition: game.cpp:2958
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11081 of file game.cpp.

11082{
11083 if( !critter.is_hallucination() ) {
11084 // hallucinations aren't stored, they come and go as they like,
11086 }
11087
11088 critter.on_unload();
11089 remove_zombie( critter );
11090 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11091 critter.set_hp( 0 );
11092}
void remove_zombie(const monster &critter)
Definition: game.cpp:4840
bool is_hallucination() const override
Definition: monster.cpp:2673
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:3005
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1656
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 8704 of file game.cpp.

8705{
8706 monster *const mon_ptr = critter_at<monster>( p );
8707 if( !mon_ptr ) {
8708 return false;
8709 }
8710 monster &critter = *mon_ptr;
8711 if( critter.friendly == 0 || critter.has_effect( effect_pet ) ||
8712 critter.has_flag( MF_RIDEABLE_MECH ) ||
8713 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
8714 // Can only disable / reprogram friendly monsters
8715 return false;
8716 }
8717 const auto mid = critter.type->id;
8718 const auto mon_item_id = critter.type->revert_to_itype;
8719 if( !mon_item_id.is_empty() &&
8720 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
8721
8722 u.moves -= 100;
8723 m.add_item_or_charges( p, critter.to_item() );
8724 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
8725 for( auto &ammodef : critter.ammo ) {
8726 if( ammodef.second > 0 ) {
8727 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
8728 }
8729 }
8730 }
8731 remove_zombie( critter );
8732 return true;
8733 }
8734 // Manhacks are special, they have their own menu here.
8735 if( mid == mon_manhack ) {
8736 int choice = UILIST_CANCEL;
8737 if( critter.has_effect( effect_docile ) ) {
8738 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
8739 } else {
8740 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
8741 }
8742 switch( choice ) {
8743 case 0:
8744 if( critter.has_effect( effect_docile ) ) {
8745 critter.remove_effect( effect_docile );
8746 if( one_in( 3 ) ) {
8747 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
8748 critter.name() );
8749 }
8750 } else {
8751 critter.add_effect( effect_docile, 1_turns, num_bp );
8752 if( one_in( 3 ) ) {
8753 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
8754 critter.name() );
8755 }
8756 }
8757 u.moves -= 100;
8758 return true;
8759 default:
8760 break;
8761 }
8762 }
8763 return false;
8764}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1136
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4175
bool has_flag(m_flag f) const override
Definition: monster.cpp:889
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2813
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1832
int friendly
Definition: monster.h:474
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:493
std::map< itype_id, int > ammo
Definition: monster.h:515
static const efftype_id effect_pet("pet")
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:364
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, effect_pet, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 2941 of file game.cpp.

2942{
2943 // TODO: This search needs to be expanded to all NPCs
2944 for( auto elem : follower_ids ) {
2946 if( !guy ) {
2947 continue;
2948 }
2949 const auto new_win = []() {
2951 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2952 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2953 };
2954 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
2955 }
2956}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 2992 of file game.cpp.

2993{
2994 const tripoint_abs_omt ppos = u.global_omt_location();
2995 const tripoint &lpos = u.pos();
2996 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
2997 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
2998
3000 ui_adaptor ui;
3001 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
3004 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
3005 ui.position_from_window( w );
3006 } );
3007 ui.mark_resize();
3008 ui.on_redraw( [&]( const ui_adaptor & ) {
3009 werase( w );
3010 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3011 // NOLINTNEXTLINE(cata-use-named-point-constants)
3012 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3013 size_t i;
3014 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3015 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3016 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3017 apos.to_string() );
3018 }
3019 for( const monster &m : all_monsters() ) {
3020 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3021 m.posx(), m.posy(), m.posz() );
3022 ++i;
3023 }
3024 wnoutrefresh( w );
3025 } );
3026
3027 input_context ctxt( "DISP_NPCS" );
3028 ctxt.register_action( "CONFIRM" );
3029 ctxt.register_action( "QUIT" );
3030 ctxt.register_action( "HELP_KEYBINDINGS" );
3031 bool stop = false;
3032 while( !stop ) {
3034 const std::string action = ctxt.handle_input();
3035 if( action == "CONFIRM" || action == "QUIT" ) {
3036 stop = true;
3037 }
3038 }
3039}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6336
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1322
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 2958 of file game.cpp.

2959{
2960 for( const auto &elem : faction_manager_ptr->all() ) {
2961 if( elem.second.known_by_u ) {
2962 const std::vector<std::string> epilogue = elem.second.epilogue();
2963 if( !epilogue.empty() ) {
2964 const auto new_win = []() {
2966 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2967 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2968 };
2969 scrollable_text( new_win, elem.second.name,
2970 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
2971 []( const std::string & lhs, const std::string & rhs ) -> std::string {
2972 return lhs + "\n" + rhs;
2973 } ) );
2974 }
2975 }
2976 }
2977}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:995

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11293 of file game.cpp.

11294{
11295 if( use_tiles ) {
11297 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11298 return;
11299 }
11300 uilist lighting_menu;
11301 std::vector<std::string> lighting_menu_strings{
11302 "Global lighting conditions"
11303 };
11304
11305 int count = 0;
11306 for( const auto &menu_str : lighting_menu_strings ) {
11307 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11308 }
11309
11310 lighting_menu.w_y_setup = 0;
11311 lighting_menu.query();
11312 if( ( lighting_menu.ret >= 0 ) &&
11313 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11314 g->displaying_lighting_condition = lighting_menu.ret;
11315 }
11316 }
11317}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11189
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11184 of file game.cpp.

11185{
11187}
cata::optional< action_id > displaying_overlays
Definition: game.h:940

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11319 of file game.cpp.

11320{
11321 if( use_tiles ) {
11323 }
11324}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11198 of file game.cpp.

11199{
11200 if( use_tiles ) {
11202 } else {
11203 int div;
11204 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11205 if( !got_value || div < 1 ) {
11206 add_msg( _( "Never mind." ) );
11207 return;
11208 }
11209 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11210 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11211 } );
11212 g->add_draw_callback( scent_cb );
11213
11216 }
11217}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:587
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11219 of file game.cpp.

11220{
11221 if( use_tiles ) {
11223 }
11224}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11189 of file game.cpp.

11190{
11191 if( display_overlay_state( action ) ) {
11192 displaying_overlays.reset();
11193 } else {
11195 }
11196}
bool display_overlay_state(action_id)
Definition: game.cpp:11184

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11326 of file game.cpp.

11327{
11328 if( use_tiles ) {
11330 }
11331}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11226 of file game.cpp.

11227{
11228 if( use_tiles ) {
11230 }
11231}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11233 of file game.cpp.

11234{
11235 if( use_tiles ) {
11238 std::vector< tripoint > locations;
11239 uilist creature_menu;
11240 int num_creatures = 0;
11241 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11242 locations.emplace_back( g->u.pos() ); // add player first.
11243 for( const Creature &critter : g->all_creatures() ) {
11244 if( critter.is_player() ) {
11245 continue;
11246 }
11247 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11248 locations.emplace_back( critter.pos() );
11249 }
11250
11251 pointmenu_cb callback( locations );
11252 creature_menu.callback = &callback;
11253 creature_menu.w_y_setup = 0;
11254 creature_menu.query();
11255 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11256 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11258 }
11259 } else {
11261 }
11262 }
11263}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:4830
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1031
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1444 of file game.cpp.

1445{
1446 if( is_game_over() ) {
1447 return cleanup_at_end();
1448 }
1449 // Actual stuff
1450 if( new_game ) {
1451 new_game = false;
1452 } else {
1453 gamemode->per_turn();
1454 calendar::turn += 1_turns;
1455 }
1456
1457 // starting a new turn, clear out temperature cache
1459 weather.clear_temp_cache();
1460
1461 if( npcs_dirty ) {
1462 load_npcs();
1463 }
1464
1467 // If controlling a vehicle that is owned by someone else
1469 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1470 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1471 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1472 }
1473 }
1474 // If riding a horse - chance to spook
1475 if( u.is_mounted() ) {
1477 }
1478 if( calendar::once_every( 1_days ) ) {
1480 }
1481
1482 // Move hordes every 2.5 min
1485 // Hordes that reached the reality bubble need to spawn,
1486 // make them spawn in invisible areas only.
1487 m.spawn_monsters( false );
1488 }
1489
1491
1492 u.update_body();
1493
1494 // Auto-save if autosave is enabled
1495 if( get_option<bool>( "AUTOSAVE" ) &&
1496 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1497 !u.is_dead_state() ) {
1498 autosave();
1499 }
1500
1501 weather.update_weather();
1503
1507 // Process NPC sound events before they move or they hear themselves talking
1508 for( npc &guy : all_npcs() ) {
1509 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1511 }
1512 }
1513
1514 // Process sound events into sound markers for display to the player.
1516
1517 if( u.is_deaf() ) {
1519 }
1520
1521 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1522 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1523 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1524 cleanup_dead();
1526 // Process any new sounds the player caused during their turn.
1527 for( npc &guy : all_npcs() ) {
1528 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1530 }
1531 }
1534 wait_popup.reset();
1536 }
1537
1538 if( queue_screenshot ) {
1542 queue_screenshot = false;
1543 }
1544
1545 if( handle_action() ) {
1547 u.action_taken();
1548 }
1549
1550 if( is_game_over() ) {
1551 return cleanup_at_end();
1552 }
1553
1554 if( uquit == QUIT_WATCH ) {
1555 break;
1556 }
1557 if( u.activity ) {
1559 }
1560 }
1561 // Reset displayed sound markers now that the turn is over.
1562 // We only want this to happen if the player had a chance to examine the sounds.
1564 }
1565 }
1566
1567 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1568 // Still have a view offset, but might not be driving anymore,
1569 // or the option has been deactivated,
1570 // might also happen when someone dives from a moving car.
1571 // or when using the handbrake.
1572 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1573 calc_driving_offset( veh );
1574 }
1575
1576 // No-scent debug mutation has to be processed here or else it takes time to start working
1577 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1578 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1581 }
1582 scent.update( u.pos(), m );
1583
1584 // We need floor cache before checking falling 'n stuff
1586
1589 m.vehmove();
1590 m.process_fields();
1591 m.process_items();
1594
1595 // Apply sounds from previous turn to monster and NPC AI.
1597 // Update vision caches for monsters. If this turns out to be expensive,
1598 // consider a stripped down cache just for monsters.
1599 m.build_map_cache( get_levz(), true );
1600 monmove();
1601 if( calendar::once_every( 5_minutes ) ) {
1603 }
1604 if( calendar::once_every( 10_seconds ) ) {
1605 for( const tripoint &elem : m.get_furn_field_locations() ) {
1606 const auto &furn = m.furn( elem ).obj();
1607 for( const emit_id &e : furn.emissions ) {
1608 m.emit_field( elem, e );
1609 }
1610 }
1611 }
1614 u.process_turn();
1615
1617 cleanup_dead();
1618
1619 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1622 }
1623
1624 if( get_levz() >= 0 && !u.is_underwater() ) {
1625 handle_weather_effects( weather.weather_id );
1626 }
1627
1628 const bool player_is_sleeping = u.has_effect( effect_sleep );
1629 bool wait_redraw = false;
1630 std::string wait_message;
1631 time_duration wait_refresh_rate;
1632 if( player_is_sleeping ) {
1633 wait_redraw = true;
1634 wait_message = _( "Wait till you wake up…" );
1635 wait_refresh_rate = 30_minutes;
1636 if( calendar::once_every( 1_hours ) ) {
1638 }
1639 } else if( u.has_destination() ) {
1640 wait_redraw = true;
1641 wait_message = _( "Travelling…" );
1642 wait_refresh_rate = 15_turns;
1643 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1644 wait_redraw = true;
1645 wait_message = *progress;
1646 if( u.activity.id() == ACT_AUTODRIVE ) {
1647 wait_refresh_rate = 1_turns;
1648 } else {
1649 wait_refresh_rate = 5_minutes;
1650 }
1651 }
1652 if( wait_redraw ) {
1654 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1655 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1657 }
1658
1659 // Avoid redrawing the main UI every time due to invalidation
1661 wait_popup = std::make_unique<static_popup>();
1662 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1666 }
1667 } else {
1668 // Nothing to wait for now
1669 wait_popup.reset();
1671 }
1672
1674 u.update_body_wetness( get_weather().get_precise() );
1675 u.apply_wetness_morale( weather.temperature );
1676
1677 if( calendar::once_every( 1_minutes ) ) {
1678 u.update_morale();
1679 }
1680
1681 if( calendar::once_every( 9_turns ) ) {
1683 }
1684
1685 if( !u.is_deaf() ) {
1687 }
1692
1693 // reset player noise
1694 u.volume = 0;
1695
1696 return false;
1697}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:9000
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:877
bool check_mount_is_spooked()
Definition: character.cpp:1102
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5183
bool is_mounted() const
Definition: character.cpp:1143
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8759
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9127
bool is_deaf() const
Definition: character.cpp:4486
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4665
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1887
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1802
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:11951
void overmap_npc_move()
Definition: game.cpp:4331
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12061
void monmove()
Definition: game.cpp:4206
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1761
void add_artifact_dreams()
Definition: game.cpp:11895
int moves_since_last_save
Definition: game.h:1061
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7228
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1342
bool cleanup_at_end()
Definition: game.cpp:1038
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1097
bool queue_screenshot
Definition: game.h:1040
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11384
void process_activity()
Definition: game.cpp:1750
void update_stair_monsters()
Definition: game.cpp:10872
void process_voluntary_act_interrupt()
Definition: game.cpp:1711
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:906
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1068
void cleanup_dead()
Definition: game.cpp:4171
bool is_game_over()
Definition: game.cpp:2457
void perhaps_add_random_npc()
Definition: game.cpp:11119
void mon_info_update()
Definition: game.cpp:3970
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:8037
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2271
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1928
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7734
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7693
void vehmove()
Definition: map.cpp:412
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1563
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1345
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8203
void process_items()
Definition: map.cpp:4561
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:777
int volume
Definition: player.h:590
int scent
Definition: player.h:599
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1564
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:277
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:150
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1170
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3229 of file game.cpp.

3230{
3231 if( test_mode ) {
3232 return;
3233 }
3234
3235 //temporary fix for updating visibility for minimap
3236 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3239
3240 werase( w_terrain );
3241 draw_ter();
3242 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3243 shared_ptr_fast<draw_callback_t> cb = it->lock();
3244 if( cb ) {
3245 ( *cb )();
3246 ++it;
3247 } else {
3248 it = draw_callbacks.erase( it );
3249 }
3250 }
3252
3253 draw_panels( true );
3254}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1007
void draw_panels(bool force_draw=false)
Definition: game.cpp:3256
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3370
void update_visibility_cache(int zlev)
Definition: map.cpp:5588
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 955 of file animation.cpp.

956{
957}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 510 of file animation.cpp.

512{
513 draw_bullet_curses( m, t, bullet, &trajectory[i] );
514}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:451
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3352 of file game.cpp.

3353{
3354 draw_critter_internal( w_terrain, critter, center, false, m, u );
3355}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3319

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3357 of file game.cpp.

3358{
3359 draw_critter_internal( w_terrain, critter, center, true, m, u );
3360}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 716 of file animation.cpp.

717{
718 const tripoint rp = relative_view_pos( *this, p );
719 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
720}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:119
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 911 of file animation.cpp.

912{
913}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 872 of file animation.cpp.

873{
874}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 885 of file animation.cpp.

886{
887}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 729 of file animation.cpp.

730{
731 // Do nothing
732}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 573 of file animation.cpp.

574{
575 draw_hit_mon_curses( p, m, u, dead );
576}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:544

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 618 of file animation.cpp.

619{
620 draw_hit_player_curses( *this, p, dam );
621}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:581

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 925 of file animation.cpp.

927{
928}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 702 of file animation.cpp.

703{
704 draw_line_curses( *this, points );
705}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:682

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 669 of file animation.cpp.

671{
672 if( !u.sees( p ) ) {
673 return;
674 }
675
676 draw_line_curses( *this, center, points, noreveal );
677}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5767 of file game.cpp.

5768{
5769 if( !liveview.is_enabled() ) {
5770#if defined( TILES )
5771 if( is_draw_tiles_mode() ) {
5772 draw_cursor( lp );
5773 return;
5774 }
5775#endif
5776 const tripoint view_center = u.pos() + u.view_offset;
5777 visibility_type visibility = VIS_HIDDEN;
5778 const bool inbounds = m.inbounds( lp );
5779 if( inbounds ) {
5780 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5781 }
5782 if( visibility == VIS_CLEAR ) {
5783 const Creature *const creature = critter_at( lp, true );
5784 if( creature != nullptr && u.sees( *creature ) ) {
5785 creature->draw( w_terrain, view_center, true );
5786 } else {
5787 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5788 }
5789 } else {
5790 std::string visibility_indicator;
5791 nc_color visibility_indicator_color = c_white;
5792 switch( visibility ) {
5793 case VIS_CLEAR:
5794 // Already handled by the outer if statement
5795 break;
5796 case VIS_BOOMER:
5797 case VIS_BOOMER_DARK:
5798 visibility_indicator = '#';
5799 visibility_indicator_color = c_pink;
5800 break;
5801 case VIS_DARK:
5802 visibility_indicator = '#';
5803 visibility_indicator_color = c_dark_gray;
5804 break;
5805 case VIS_LIT:
5806 visibility_indicator = '#';
5807 visibility_indicator_color = c_light_gray;
5808 break;
5809 case VIS_HIDDEN:
5810 visibility_indicator = 'x';
5811 visibility_indicator_color = c_white;
5812 break;
5813 }
5814
5815 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
5816 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
5817 }
5818 }
5819}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:716
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4650
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7744
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5642
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:700
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5820
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:180

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3430 of file game.cpp.

3431{
3432
3433 // Draw the box
3434 werase( w_minimap );
3436
3437 const tripoint_abs_omt curs = u.global_omt_location();
3438 const point_abs_omt curs2( curs.xy() );
3440 bool drew_mission = targ == overmap::invalid_tripoint;
3441
3442 for( int i = -2; i <= 2; i++ ) {
3443 for( int j = -2; j <= 2; j++ ) {
3444 const point_abs_omt om( curs2 + point( i, j ) );
3445 nc_color ter_color;
3446 tripoint_abs_omt omp( om, get_levz() );
3447 std::string ter_sym;
3448 const bool seen = overmap_buffer.seen( omp );
3449 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3450 if( overmap_buffer.has_note( omp ) ) {
3451
3452 const std::string &note_text = overmap_buffer.note( omp );
3453
3454 ter_color = c_yellow;
3455 ter_sym = "N";
3456
3457 int symbolIndex = note_text.find( ':' );
3458 int colorIndex = note_text.find( ';' );
3459
3460 bool symbolFirst = symbolIndex < colorIndex;
3461
3462 if( colorIndex > -1 && symbolIndex > -1 ) {
3463 if( symbolFirst ) {
3464 if( colorIndex > 4 ) {
3465 colorIndex = -1;
3466 }
3467 if( symbolIndex > 1 ) {
3468 symbolIndex = -1;
3469 colorIndex = -1;
3470 }
3471 } else {
3472 if( symbolIndex > 4 ) {
3473 symbolIndex = -1;
3474 }
3475 if( colorIndex > 2 ) {
3476 colorIndex = -1;
3477 }
3478 }
3479 } else if( colorIndex > 2 ) {
3480 colorIndex = -1;
3481 } else if( symbolIndex > 1 ) {
3482 symbolIndex = -1;
3483 }
3484
3485 if( symbolIndex > -1 ) {
3486 int symbolStart = 0;
3487 if( colorIndex > -1 && !symbolFirst ) {
3488 symbolStart = colorIndex + 1;
3489 }
3490 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3491 }
3492
3493 if( colorIndex > -1 ) {
3494
3495 int colorStart = 0;
3496
3497 if( symbolIndex > -1 && symbolFirst ) {
3498 colorStart = symbolIndex + 1;
3499 }
3500
3501 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3502
3503 if( sym.length() == 2 ) {
3504 if( sym == "br" ) {
3505 ter_color = c_brown;
3506 } else if( sym == "lg" ) {
3507 ter_color = c_light_gray;
3508 } else if( sym == "dg" ) {
3509 ter_color = c_dark_gray;
3510 }
3511 } else {
3512 char colorID = sym.c_str()[0];
3513 if( colorID == 'r' ) {
3514 ter_color = c_light_red;
3515 } else if( colorID == 'R' ) {
3516 ter_color = c_red;
3517 } else if( colorID == 'g' ) {
3518 ter_color = c_light_green;
3519 } else if( colorID == 'G' ) {
3520 ter_color = c_green;
3521 } else if( colorID == 'b' ) {
3522 ter_color = c_light_blue;
3523 } else if( colorID == 'B' ) {
3524 ter_color = c_blue;
3525 } else if( colorID == 'W' ) {
3526 ter_color = c_white;
3527 } else if( colorID == 'C' ) {
3528 ter_color = c_cyan;
3529 } else if( colorID == 'c' ) {
3530 ter_color = c_light_cyan;
3531 } else if( colorID == 'P' ) {
3532 ter_color = c_pink;
3533 } else if( colorID == 'm' ) {
3534 ter_color = c_magenta;
3535 }
3536 }
3537 }
3538 } else if( !seen ) {
3539 ter_sym = " ";
3540 ter_color = c_black;
3541 } else if( vehicle_here ) {
3542 ter_color = c_cyan;
3543 ter_sym = "c";
3544 } else {
3545 const oter_id &cur_ter = overmap_buffer.ter( omp );
3546 ter_sym = cur_ter->get_symbol();
3547 if( overmap_buffer.is_explored( omp ) ) {
3548 ter_color = c_dark_gray;
3549 } else {
3550 ter_color = cur_ter->get_color();
3551 }
3552 }
3553 if( !drew_mission && targ.xy() == omp.xy() ) {
3554 // If there is a mission target, and it's not on the same
3555 // overmap terrain as the player character, mark it.
3556 // TODO: Inform player if the mission is above or below
3557 drew_mission = true;
3558 if( i != 0 || j != 0 ) {
3559 ter_color = red_background( ter_color );
3560 }
3561 }
3562 if( i == 0 && j == 0 ) {
3563 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3564 } else {
3565 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3566 }
3567 }
3568 }
3569
3570 // Print arrow to mission if we have one!
3571 if( !drew_mission ) {
3572 double slope = curs2.x() != targ.x() ?
3573 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3574
3575 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3576 if( targ.y() > curs2.y() ) {
3577 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3578 } else {
3579 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3580 }
3581 } else {
3582 int arrowx = -1;
3583 int arrowy = -1;
3584 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3585 arrowy = targ.y() > curs2.y() ? 6 : 0;
3586 arrowx =
3587 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3588 if( arrowx < 0 ) {
3589 arrowx = 0;
3590 }
3591 if( arrowx > 6 ) {
3592 arrowx = 6;
3593 }
3594 } else {
3595 arrowx = targ.x() > curs2.x() ? 6 : 0;
3596 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3597 if( arrowy < 0 ) {
3598 arrowy = 0;
3599 }
3600 if( arrowy > 6 ) {
3601 arrowy = 6;
3602 }
3603 }
3604 char glyph = '*';
3605 if( targ.z() > u.posz() ) {
3606 glyph = '^';
3607 } else if( targ.z() < u.posz() ) {
3608 glyph = 'v';
3609 }
3610
3611 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3612 }
3613 }
3614
3615 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3616 for( int i = -3; i <= 3; i++ ) {
3617 for( int j = -3; j <= 3; j++ ) {
3618 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3619 continue; // only do hordes on the border, skip inner map
3620 }
3621 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3623 if( overmap_buffer.seen( omp )
3624 && g->u.overmap_los( omp, sight_points ) ) {
3625 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3626 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3627 }
3628 }
3629 }
3630 }
3631
3633}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:203
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 969 of file animation.cpp.

971{
972}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3256 of file game.cpp.

3257{
3258 static int previous_turn = -1;
3259 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3260 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3261 auto &mgr = panel_manager::get_manager();
3262 int y = 0;
3263 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3264 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3265 int log_height = 0;
3266 for( const window_panel &panel : mgr.get_current_layout() ) {
3267 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3268 log_height += panel.get_height() + spacer;
3269 }
3270 }
3271 log_height = std::max( TERMY - log_height, 3 );
3272 for( const window_panel &panel : mgr.get_current_layout() ) {
3273 if( panel.render() ) {
3274 // height clamped to window height.
3275 int h = std::min( panel.get_height(), TERMY - y );
3276 if( h == -2 ) {
3277 h = log_height;
3278 }
3279 h += spacer;
3280 if( panel.toggle && panel.render() && h > 0 ) {
3281 if( panel.always_draw || draw_this_turn ) {
3282 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3283 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3284 }
3285 if( show_panel_adm ) {
3286 const std::string panel_name = _( panel.get_name() );
3287 const int panel_name_width = utf8_width( panel_name );
3288 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3289 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3290 werase( label );
3291 mvwprintz( label, point_zero, c_light_red, panel_name );
3293 label = catacurses::newwin( h, 1,
3294 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3295 werase( label );
3296 if( h == 1 ) {
3298 } else {
3300 for( int i = 1; i < h - 1; i++ ) {
3302 }
3303 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3304 }
3306 }
3307 y += h;
3308 }
3309 }
3310 }
3311 previous_turn = current_turn;
3312}
bool show_panel_adm
Definition: game.h:1035
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3314 of file game.cpp.

3315{
3316 w_pixel_minimap = w;
3317}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 846 of file animation.cpp.

847{
848}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 797 of file animation.cpp.

798{
799 draw_sct_curses( *this );
800}
void draw_sct_curses(const game &g)
Definition: animation.cpp:764

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3370 of file game.cpp.

3371{
3373 draw_sounds );
3374}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3376 of file game.cpp.

3377{
3379
3380 m.draw( w_terrain, center );
3381
3382 if( draw_sounds ) {
3384 }
3385
3386 for( Creature &critter : all_creatures() ) {
3387 draw_critter( critter, center );
3388 }
3389
3390 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3391 // Draw auto-move preview trail
3392 const tripoint &final_destination = destination_preview.back();
3393 tripoint line_center = u.pos() + u.view_offset;
3394 draw_line( final_destination, line_center, destination_preview, true );
3395 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3396 POSY - u.posy() ), c_white, 'X' );
3397 }
3398
3399 if( u.controlling_vehicle && !looking ) {
3400 draw_veh_dir_indicator( false );
3401 draw_veh_dir_indicator( true );
3402 }
3403 // Place the cursor over the player as is expected by screen readers.
3404 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3405}
int posx() const override
Definition: character.h:779
int posy() const override
Definition: character.h:782
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3352
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12051
std::vector< tripoint > destination_preview
Definition: game.h:1087
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3422
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:669
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5692
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3042
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 859 of file animation.cpp.

860{
861}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7076 of file game.cpp.

7077{
7078 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7079}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7046

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 898 of file animation.cpp.

899{
900}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3422 of file game.cpp.

3423{
3424 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3425 auto col = next ? c_white : c_dark_gray;
3426 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3427 }
3428}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3407

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 941 of file animation.cpp.

943{
944}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 756 of file animation.cpp.

757{
759}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:737

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 832 of file animation.cpp.

833{
834 draw_zones_curses( w_terrain, start, end, offset );
835}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8118 of file game.cpp.

8119{
8121}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2505
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8123 of file game.cpp.

8124{
8125 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8126 u.drop( game_menus::inv::multidrop( u ), *pnt );
8127 }
8128}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 37 of file dump.cpp.

39{
40 try {
41 loading_ui ui( false );
43 load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
45 } catch( const std::exception &err ) {
46 std::cerr << "Error loading data from json: " << err.what() << std::endl;
47 return false;
48 }
49
50 std::vector<std::string> header;
51 std::vector<std::vector<std::string>> rows;
52
53 int scol = 0; // sorting column
54
55 std::map<std::string, standard_npc> test_npcs;
56 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
57 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
58 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
59 4, 8, 8, 8, 10 /* PER 10 */ );
60 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
61 4, 10, 8, 8, 8 /* STAT 10 */ );
62 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
65 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
66
67 std::map<std::string, item> test_items;
68 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
71 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
72 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
73
74 if( what == "AMMO" ) {
75 header = {
76 "Name", "Ammo", "Volume", "Weight", "Stack",
77 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
78 };
79 auto dump = [&rows]( const item & obj ) {
80 std::vector<std::string> r;
81 r.push_back( obj.tname( 1, false ) );
82 r.push_back( obj.ammo_type().str() );
83 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
84 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
85 r.push_back( std::to_string( obj.type->stack_size ) );
86 r.push_back( std::to_string( obj.type->ammo->range ) );
87 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
88 r.push_back( std::to_string( obj.type->ammo->recoil ) );
89 damage_instance damage = obj.type->ammo->damage;
90 r.push_back( std::to_string( damage.total_damage() ) );
91 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
92 rows.push_back( r );
93 };
94 for( const itype *e : item_controller->all() ) {
95 if( e->ammo ) {
96 dump( item( e, calendar::turn, item::solitary_tag {} ) );
97 }
98 }
99
100 } else if( what == "ARMOR" ) {
101 header = {
102 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
103 };
104 auto dump = [&rows]( const item & obj ) {
105 std::vector<std::string> r;
106 r.push_back( obj.tname( 1, false ) );
107 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
108 r.push_back( std::to_string( obj.get_warmth() ) );
109 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
110 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
111 r.push_back( std::to_string( obj.get_coverage() ) );
112 r.push_back( std::to_string( obj.bash_resist() ) );
113 r.push_back( std::to_string( obj.cut_resist() ) );
114 r.push_back( std::to_string( obj.bullet_resist() ) );
115 r.push_back( std::to_string( obj.acid_resist() ) );
116 r.push_back( std::to_string( obj.fire_resist() ) );
117 rows.push_back( r );
118 };
119
120 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
121
122 for( const itype *e : item_controller->all() ) {
123 if( e->armor ) {
124 item obj( e );
125 if( bp == num_bp || obj.covers( bp ) ) {
126 if( obj.has_flag( flag_VARSIZE ) ) {
127 obj.set_flag( "FIT" );
128 }
129 dump( obj );
130 }
131 }
132 }
133
134 } else if( what == "EDIBLE" ) {
135 header = {
136 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
137 };
138 for( const auto &v : vitamin::all() ) {
139 header.push_back( v.second.name() );
140 }
141 auto dump = [&rows]( const item & obj ) {
142 std::vector<std::string> r;
143 r.push_back( obj.tname( 1, false ) );
144 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
145 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
146 r.push_back( std::to_string( obj.type->stack_size ) );
147 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
148 r.push_back( std::to_string( obj.get_comestible()->quench ) );
149 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
150 auto vits = obj.get_comestible()->default_nutrition.vitamins;
151 for( const auto &v : vitamin::all() ) {
152 r.push_back( std::to_string( vits[ v.first ] ) );
153 }
154 rows.push_back( r );
155 };
156
157 for( const itype *e : item_controller->all() ) {
159
160 if( food.is_food() && g->u.can_eat( food ).success() ) {
161 dump( food );
162 }
163 }
164
165 } else if( what == "GUN" ) {
166 header = {
167 "Name", "Ammo", "Volume", "Weight", "Capacity",
168 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
169 "Aim time", "Effective range", "Snapshot range", "Max range"
170 };
171
172 std::set<std::string> locations;
173 for( const itype *e : item_controller->all() ) {
174 if( e->gun ) {
175 std::transform( e->gun->valid_mod_locations.begin(),
176 e->gun->valid_mod_locations.end(),
177 std::inserter( locations, locations.begin() ),
178 []( const std::pair<gunmod_location, int> &q ) {
179 return q.first.name();
180 } );
181 }
182 }
183 for( const auto &e : locations ) {
184 header.push_back( e );
185 }
186
187 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
188 std::vector<std::string> r;
189 r.push_back( obj.tname( 1, false ) );
190 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
191 obj.ammo_types().end(), []( const ammotype & at ) {
192 return at.str();
194 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
195 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
196 r.push_back( std::to_string( obj.ammo_capacity() ) );
197 r.push_back( std::to_string( obj.gun_range() ) );
198 r.push_back( std::to_string( obj.gun_dispersion() ) );
199 r.push_back( std::to_string( obj.gun_recoil() ) );
200 damage_instance damage = obj.gun_damage();
201 r.push_back( std::to_string( damage.total_damage() ) );
202 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
203
204 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
205
206 for( const auto &e : locations ) {
207 const auto &vml = obj.type->gun->valid_mod_locations;
208 const auto iter = vml.find( e );
209 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
210 }
211 rows.push_back( r );
212 };
213 for( const itype *e : item_controller->all() ) {
214 if( e->gun ) {
215 item gun( e );
216 if( !gun.magazine_integral() ) {
217 gun.put_in( item( gun.magazine_default() ) );
218 }
219 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
220
221 dump( test_npcs[ "S1" ], gun );
222
223 if( gun.type->gun->barrel_length > 0_ml ) {
224 gun.put_in( item( "barrel_small" ) );
225 dump( test_npcs[ "S1" ], gun );
226 }
227 }
228 }
229
230 } else if( what == "RECIPE" ) {
231
232 // optionally filter recipes to include only those using specified skills
233 recipe_subset dict;
234 for( const auto &r : recipe_dict ) {
235 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
236 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
237 return true;
238 }
239 const auto iter = r.second.required_skills.find( skill_id( s ) );
240 return iter != r.second.required_skills.end() && iter->second > 0;
241 } ) ) {
242 dict.include( &r.second );
243 }
244 }
245
246 // only consider skills that are required by at least one recipe
247 std::vector<Skill> sk;
248 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
249 std::back_inserter( sk ), [&dict]( const Skill & s ) {
250 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
251 return r->skill_used == s.ident() ||
252 r->required_skills.find( s.ident() ) != r->required_skills.end();
253 } );
254 } );
255
256 header = { "Result" };
257
258 for( const auto &e : sk ) {
259 header.push_back( e.ident().str() );
260 }
261
262 for( const recipe *e : dict ) {
263 std::vector<std::string> r;
264 r.push_back( e->result_name() );
265 for( const auto &s : sk ) {
266 if( e->skill_used == s.ident() ) {
267 r.push_back( std::to_string( e->difficulty ) );
268 } else {
269 auto iter = e->required_skills.find( s.ident() );
270 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
271 }
272 }
273 rows.push_back( r );
274 }
275
276 } else if( what == "VEHICLE" ) {
277 header = {
278 "Name", "Weight (empty)", "Weight (fueled)",
279 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
280 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
281 };
282 auto dump = [&rows]( const vproto_id & obj ) {
283 vehicle veh_empty( obj, 0, 0 );
284 vehicle veh_fueled( obj, 100, 0 );
285
286 std::vector<std::string> r;
287 r.push_back( veh_empty.name );
288 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
289 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
290 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
294 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
295 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
296 r.push_back( std::to_string( static_cast<int>( 50 *
297 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
298 rows.push_back( r );
299 };
300 for( auto &e : vehicle_prototype::get_all() ) {
301 dump( e );
302 }
303
304 } else if( what == "VPART" ) {
305 header = {
306 "Name", "Location", "Weight", "Size"
307 };
308 auto dump = [&rows]( const vpart_info & obj ) {
309 std::vector<std::string> r;
310 r.push_back( obj.name() );
311 r.push_back( obj.location );
312 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
313 r.push_back( std::to_string( w ) );
314 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
315 rows.push_back( r );
316 };
317 for( const auto &e : vpart_info::all() ) {
318 dump( e.second );
319 }
320
321 } else {
322 std::cerr << "unknown argument: " << what << std::endl;
323 return false;
324 }
325
326 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
327 return e.empty();
328 } ), rows.end() );
329
330 if( scol >= 0 ) {
331 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
332 const std::vector<std::string> &rhs ) {
333 return localized_compare( lhs[ scol ], rhs[ scol ] );
334 } );
335 }
336
337 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
338
339 switch( mode ) {
340 case dump_mode::TSV:
341 rows.insert( rows.begin(), header );
342 for( const auto &r : rows ) {
343 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
344 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
345 std::cout << r.back() << "\n";
346 }
347 break;
348
349 case dump_mode::HTML:
350 std::cout << "<table>";
351
352 std::cout << "<thead>";
353 std::cout << "<tr>";
354 for( const auto &col : header ) {
355 std::cout << "<th>" << col << "</th>";
356 }
357 std::cout << "</tr>";
358 std::cout << "</thead>";
359
360 std::cout << "<tdata>";
361 for( const auto &r : rows ) {
362 std::cout << "<tr>";
363 for( const auto &col : r ) {
364 std::cout << "<td>" << col << "</td>";
365 }
366 std::cout << "</tr>";
367 }
368 std::cout << "</tdata>";
369
370 std::cout << "</table>";
371 break;
372 }
373
374 return true;
375}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2747
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4865
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:990
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:590
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1641
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:680
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:196
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157
string_id< MOD_INFORMATION > mod_id
Definition: type_id.h:98

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 2857 of file game.cpp.

2858{
2859 return *event_bus_ptr;
2860}
pimpl< event_bus > event_bus_ptr
Definition: game.h:974

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5088 of file game.cpp.

5089{
5090 if( veh.magic ) {
5091 add_msg( m_info, _( "This is your %s" ), veh.name );
5092 return;
5093 }
5094 auto act = veh_interact::run( veh, c );
5095 if( act ) {
5096 u.moves = 0;
5098 }
5099}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1866
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5468 of file game.cpp.

5469{
5470 // if we are driving a vehicle, examine the
5471 // current tile without asking.
5472 const optional_vpart_position vp = m.veh_at( u.pos() );
5473 if( vp && vp->vehicle().player_in_control( u ) ) {
5474 examine( u.pos() );
5475 return;
5476 }
5477
5478 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5479 _( "There is nothing that can be examined nearby." ),
5480 ACTION_EXAMINE, false );
5481 if( !examp_ ) {
5482 return;
5483 }
5484 u.manual_examine = true;
5485 examine( *examp_ );
5486 u.manual_examine = false;
5487}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1035
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5468
bool manual_examine
Definition: player.h:603

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5556 of file game.cpp.

5557{
5558 if( disable_robot( examp ) ) {
5559 return;
5560 }
5561
5562 Creature *c = critter_at( examp );
5563 if( c != nullptr ) {
5564 monster *mon = dynamic_cast<monster *>( c );
5565 if( mon != nullptr ) {
5566 add_msg( _( "There is a %s." ), mon->get_name() );
5567 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5568 if( monexamine::pet_menu( *mon ) ) {
5569 return;
5570 }
5571 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5572 if( monexamine::mech_hack( *mon ) ) {
5573 return;
5574 }
5575 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5576 if( monexamine::pay_bot( *mon ) ) {
5577 return;
5578 }
5579 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5580 if( monexamine::mfriend_menu( *mon ) ) {
5581 return;
5582 }
5583 }
5584 } else if( u.is_mounted() ) {
5585 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5586 }
5587 npc *np = dynamic_cast<npc *>( c );
5588 if( np != nullptr && !u.is_mounted() ) {
5589 if( npc_menu( *np ) ) {
5590 return;
5591 }
5592 } else if( np != nullptr && u.is_mounted() ) {
5593 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5594 }
5595 }
5596
5597 const optional_vpart_position vp = m.veh_at( examp );
5598 if( vp && u.is_mounted() ) {
5599 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5600 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5601 } else {
5602 vp->vehicle().interact_with( examp, vp->part_index() );
5603 return;
5604 }
5605 } else if( vp && !u.is_mounted() ) {
5606 vp->vehicle().interact_with( examp, vp->part_index() );
5607 return;
5608 }
5609
5610 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5611 use_computer( examp );
5612 return;
5613 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5614 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5615 }
5616 const furn_t &xfurn_t = m.furn( examp ).obj();
5617 const ter_t &xter_t = m.ter( examp ).obj();
5618
5619 const tripoint player_pos = u.pos();
5620
5621 if( m.has_furn( examp ) && !u.is_mounted() ) {
5622 xfurn_t.examine( u, examp );
5623 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5624 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5625 } else {
5626 if( !u.is_mounted() ) {
5627 xter_t.examine( u, examp );
5628 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5629 xter_t.examine( u, examp );
5630 } else {
5631 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5632 }
5633 }
5634
5635 // Did the player get moved? Bail out if so; our examp probably
5636 // isn't valid anymore.
5637 if( player_pos != u.pos() ) {
5638 return;
5639 }
5640
5641 bool none = true;
5642 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5643 none = false;
5644 }
5645
5646 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5647 iexamine::trap( u, examp );
5648 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5649 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5650 }
5651
5652 // In case of teleport trap or somesuch
5653 if( player_pos != u.pos() ) {
5654 return;
5655 }
5656
5657 // Feedback for fire lasting time, this can be judged while mounted
5658 const std::string fire_fuel = get_fire_fuel_string( examp );
5659 if( !fire_fuel.empty() ) {
5660 add_msg( fire_fuel );
5661 }
5662
5663 if( m.has_flag( "SEALED", examp ) ) {
5664 if( none ) {
5665 if( m.has_flag( "UNSTABLE", examp ) ) {
5666 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5667 } else {
5668 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5669 }
5670 }
5671 } else {
5672 //examp has no traps, is a container and doesn't have a special examination function
5673 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5674 m.has_flag( "CONTAINER", examp ) && none ) {
5675 add_msg( _( "It is empty." ) );
5676 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5677 xfurn_t.examine == &iexamine::fireplace ) ||
5678 xfurn_t.examine == &iexamine::workbench ) {
5679 return;
5680 } else {
5682 if( !u.is_mounted() ) {
5683 pickup::pick_up( examp, 0 );
5684 }
5685 }
5686 }
5687}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1556
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4618
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:8704
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5359
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1340
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5117
ter_id ter(const tripoint &p) const
Definition: map.cpp:1495
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1040
std::string get_name() const override
Definition: monster.cpp:488
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5489
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2893
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6080
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:247
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3792
bool pet_menu(monster &z)
Definition: monexamine.cpp:67
bool mech_hack(monster &z)
Definition: monexamine.cpp:425
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:497
bool pay_bot(monster &z)
Definition: monexamine.cpp:457
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 51 of file descriptions.cpp.

52{
54 const int top = 3;
55 int width = 0;
56 catacurses::window w_head;
57 catacurses::window w_main;
58 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
59 const int left = 0;
60 const int right = TERMX;
61 const int bottom = TERMY;
62 width = right - left;
63 const int height = bottom - top;
64 w_head = catacurses::newwin( top, TERMX, point_zero );
65 w_main = catacurses::newwin( height, width, point( left, top ) );
66 ui.position( point_zero, point( TERMX, TERMY ) );
67 } );
68 ui.mark_resize();
69
70 // Default to critter (if any), furniture (if any), then terrain.
72 if( seen_critter( *this, p ) != nullptr ) {
74 } else if( get_map().has_furn( p ) ) {
76 }
77
78 std::string action;
79 input_context ctxt( "EXTENDED_DESCRIPTION" );
80 ctxt.register_action( "CREATURE" );
81 ctxt.register_action( "FURNITURE" );
82 ctxt.register_action( "TERRAIN" );
83 ctxt.register_action( "CONFIRM" );
84 ctxt.register_action( "QUIT" );
85 ctxt.register_action( "HELP_KEYBINDINGS" );
86
87 ui.on_redraw( [&]( const ui_adaptor & ) {
88 werase( w_head );
90 _( "[%s] describe creatures, [%s] describe furniture, "
91 "[%s] describe terrain, [%s] close." ),
92 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
93 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
94
95 // Set up line drawings
96 for( int i = 0; i < TERMX; i++ ) {
97 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
98 }
99
100 wnoutrefresh( w_head );
101
102 std::string desc;
103 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
104 switch( cur_target ) {
106 const Creature *critter = seen_critter( *this, p );
107 if( critter != nullptr ) {
108 desc = critter->extended_description();
109 } else {
110 desc = _( "You do not see any creature here." );
111 }
112 }
113 break;
115 if( !u.sees( p ) || !m.has_furn( p ) ) {
116 desc = _( "You do not see any furniture here." );
117 } else {
118 const furn_id fid = m.furn( p );
119 if( debug_mode ) {
120 const std::string mod_src = enumerate_as_string( fid->src.begin(),
121 fid->src.end(), []( const std::pair<furn_str_id, mod_id> &source ) {
122 return string_format( "'%s'", source.second->name() );
124 desc = string_format( _( "Origin: %s\n%s" ), mod_src, fid->extended_description() );
125 } else {
126 desc = fid.obj().extended_description();
127 }
128 }
129 break;
131 if( !u.sees( p ) ) {
132 desc = _( "You can't see the terrain here." );
133 } else {
134 const ter_id tid = m.ter( p );
135 if( debug_mode ) {
136 const std::string mod_src = enumerate_as_string( tid->src.begin(),
137 tid->src.end(), []( const std::pair<ter_str_id, mod_id> &source ) {
138 return string_format( "'%s'", source.second->name() );
140 desc = string_format( _( "Origin: %s\n%s" ), mod_src, tid->extended_description() );
141 } else {
142 desc = tid.obj().extended_description();
143 }
144 }
145 break;
146 }
147
148 std::string signage = m.get_signage( p );
149 if( !signage.empty() ) {
150 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
151 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
152 signage );
153 }
154
155 werase( w_main );
156 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
157 wnoutrefresh( w_main );
158 } );
159
160 do {
162 action = ctxt.handle_input();
163 if( action == "CREATURE" ) {
164 cur_target = description_target::creature;
165 } else if( action == "FURNITURE" ) {
167 } else if( action == "TERRAIN" ) {
168 cur_target = description_target::terrain;
169 }
170 } while( action != "CONFIRM" && action != "QUIT" );
171}
bool debug_mode
Extended debugging mode, can be toggled during game.
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:144
std::string get_signage(const tripoint &p) const
Definition: map.cpp:3981
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::vector< std::pair< furn_str_id, mod_id > > src
Definition: mapdata.h:494
std::string extended_description() const
std::vector< std::pair< ter_str_id, mod_id > > src
Definition: mapdata.h:459

References _, action, arrow, c_light_gray, c_white, creature, debug_mode, enumerate_as_string(), map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), ter_t::src, furn_t::src, string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 7004 of file game.cpp.

7005{
7006 std::map<std::string, map_item_stack> temp_items;
7007 std::vector<map_item_stack> ret;
7008 std::vector<std::string> item_order;
7009
7010 if( u.is_blind() ) {
7011 return ret;
7012 }
7013
7014 int range = fov_3d ? fov_3d_z_range : 0;
7015 int center_z = u.pos().z;
7016
7017 for( int i = 0; i <= range * 2; i++ ) {
7018 int z = i % 2 ? center_z - i / 2 : center_z + i / 2;
7019 for( auto &points_p_it : closest_points_first( {u.pos().xy(), z}, iRadius ) ) {
7020 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
7021 u.sees( points_p_it ) &&
7022 m.sees_some_items( points_p_it, u ) ) {
7023
7024 for( auto &elem : m.i_at( points_p_it ) ) {
7025 const std::string name = elem.tname();
7026 const tripoint relative_pos = points_p_it - u.pos();
7027
7028 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
7029 item_order.push_back( name );
7030 temp_items[name] = map_item_stack( &elem, relative_pos );
7031 } else {
7032 temp_items[name].add_at_pos( &elem, relative_pos );
7033 }
7034 }
7035 }
7036 }
7037 }
7038
7039 for( auto &elem : item_order ) {
7040 ret.push_back( temp_items[elem] );
7041 }
7042
7043 return ret;
7044}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool fov_3d
3D FoV enabled/disabled.
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6342
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), fov_3d, fov_3d_z_range, map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), u, and tripoint::z.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1963 of file game.cpp.

1964{
1965 return overmap_buffer.find_npc( id ).get();
1966}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10492 of file game.cpp.

10494{
10495 const int omtilesz = SEEX * 2;
10496 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10497 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10498 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10499
10500 // Try to find the stairs.
10502 int best = INT_MAX;
10503 const int movez = z_after - get_levz();
10504 const bool going_down_1 = movez == -1;
10505 const bool going_up_1 = movez == 1;
10506 // If there are stairs on the same x and y as we currently are, use those
10507 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10508 stairs.emplace( u.pos() + tripoint_below );
10509 }
10510 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10511 stairs.emplace( u.pos() + tripoint_above );
10512 }
10513 // We did not find stairs directly above or below, so search the map for them
10514 if( !stairs.has_value() ) {
10515 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10516 if( rl_dist( u.pos(), dest ) <= best &&
10517 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10518 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10519 mp.ter( dest ) == t_manhole_cover ) ) ||
10520 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10521 stairs.emplace( dest );
10522 best = rl_dist( u.pos(), dest );
10523 }
10524 }
10525 }
10526
10527 if( stairs.has_value() ) {
10528 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10529 npc *guy = dynamic_cast<npc *>( blocking_creature );
10530 monster *mon = dynamic_cast<monster *>( blocking_creature );
10531 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10532 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10533 std::string cr_name = blocking_creature->get_name();
10534 std::string msg;
10535 if( guy ) {
10536 //~ %s is the name of hostile NPC
10537 msg = string_format( _( "%s is in the way!" ), cr_name );
10538 } else {
10539 //~ %s is some monster
10540 msg = string_format( _( "There's a %s in the way!" ), cr_name );
10541 }
10542
10543 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
10544 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
10545 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
10546 add_msg( msg );
10547 return cata::nullopt;
10548 }
10549 }
10550 return stairs;
10551 }
10552
10553 // No stairs found! Try to make some
10554 rope_ladder = false;
10555 stairs.emplace( u.pos() );
10556 stairs->z = z_after;
10557 // Check the destination area for lava.
10558 if( mp.ter( *stairs ) == t_lava ) {
10559 if( movez < 0 &&
10560 !query_yn(
10561 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
10562 return cata::nullopt;
10563 } else if( movez > 0 &&
10564 !query_yn(
10565 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
10566 return cata::nullopt;
10567 }
10568
10569 return stairs;
10570 }
10571
10572 if( movez > 0 ) {
10573 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
10574 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
10575 return cata::nullopt;
10576 }
10577 }
10578 // Manhole covers need this to work
10579 // Maybe require manhole cover here and fail otherwise?
10580 return stairs;
10581 }
10582
10583 if( mp.impassable( *stairs ) ) {
10584 popup( _( "Halfway down, the way down becomes blocked off." ) );
10585 return cata::nullopt;
10586 }
10587
10588 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
10589 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
10590 rope_ladder = true;
10591 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
10592 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
10593 } else {
10594 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
10595 }
10596 } else {
10597 return cata::nullopt;
10598 }
10599 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
10600 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
10601 if( u.has_trait( trait_VINES2 ) ) {
10602 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
10603 rope_ladder = true;
10604 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
10605 u.mod_pain( 5 );
10606 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
10607 u.mod_stored_nutr( 10 );
10608 u.mod_thirst( 10 );
10609 } else {
10610 add_msg( _( "You gingerly descend using your vines." ) );
10611 }
10612 } else {
10613 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
10614 rope_ladder = true;
10615 u.mod_stored_nutr( 10 );
10616 u.mod_thirst( 10 );
10617 }
10618 } else {
10619 return cata::nullopt;
10620 }
10621 } else if( u.has_amount( itype_grapnel, 1 ) ) {
10622 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
10623 rope_ladder = true;
10625 } else {
10626 return cata::nullopt;
10627 }
10628 } else if( u.has_amount( itype_rope_30, 1 ) ) {
10629 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
10630 rope_ladder = true;
10632 } else {
10633 return cata::nullopt;
10634 }
10635 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
10636 return cata::nullopt;
10637 }
10638
10639 return stairs;
10640}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8407
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9626
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4414
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4304
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3356
T & emplace(Args &&... args)
Definition: optional.h:146
constexpr bool has_value() const noexcept
Definition: optional.h:123
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8254
bool impassable(const tripoint &p) const
Definition: map.cpp:1792
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8583
bool is_enemy() const
Definition: npc.cpp:2043
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:945
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:10028
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 9831 of file game.cpp.

9833{
9834 if( c == nullptr ) {
9835 debugmsg( "game::fling_creature invoked on null target" );
9836 return;
9837 }
9838
9839 if( c->is_dead_state() ) {
9840 // Flinging a corpse causes problems, don't enable without testing
9841 return;
9842 }
9843
9844 if( c->is_hallucination() ) {
9845 // Don't fling hallucinations
9846 return;
9847 }
9848
9849 bool thru = true;
9850 const bool is_u = ( c == &u );
9851 // Don't animate critters getting bashed if animations are off
9852 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
9853
9854 player *p = dynamic_cast<player *>( c );
9855
9856 tileray tdir( dir );
9857 int range = flvel / 10;
9858 tripoint pt = c->pos();
9859 tripoint prev_point = pt;
9860 bool force_next = false;
9861 tripoint next_forced;
9862 while( range > 0 ) {
9863 c->underwater = false;
9864 // TODO: Check whenever it is actually in the viewport
9865 // or maybe even just redraw the changed tiles
9866 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
9867 if( force_next ) {
9868 pt = next_forced;
9869 force_next = false;
9870 } else {
9871 tdir.advance();
9872 pt.x = c->posx() + tdir.dx();
9873 pt.y = c->posy() + tdir.dy();
9874 }
9875 float force = 0;
9876
9877 if( m.obstructed_by_vehicle_rotation( prev_point, pt ) ) {
9878 //We process the intervening tile on this iteration and then the current tile on the next
9879 next_forced = pt;
9880 force_next = true;
9881 if( one_in( 2 ) ) {
9882 pt.x = prev_point.x;
9883 } else {
9884 pt.y = prev_point.y;
9885 }
9886 }
9887
9888
9889 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
9890 monster &critter = *mon_ptr;
9891 // Approximate critter's "stopping power" with its max hp
9892 force = std::min<float>( 1.5f * critter.type->hp, flvel );
9893 const int damage = rng( force, force * 2.0f ) / 6;
9894 c->impact( damage, pt );
9895 // Multiply zed damage by 6 because no body parts
9896 const int zed_damage = std::max( 0,
9897 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
9898 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
9899 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
9900 critter.check_dead_state();
9901 if( !critter.is_dead() ) {
9902 thru = false;
9903 }
9904 } else if( m.impassable( pt ) ) {
9905 if( !m.veh_at( pt ).obstacle_at_part() ) {
9906 force = std::min<float>( m.bash_strength( pt ), flvel );
9907 } else {
9908 // No good way of limiting force here
9909 // Keep it 1 less than maximum to make the impact hurt
9910 // but to keep the target flying after it
9911 force = flvel - 1;
9912 }
9913 const int damage = rng( force, force * 2.0f ) / 9;
9914 c->impact( damage, pt );
9915 if( m.is_bashable( pt ) ) {
9916 // Only go through if we successfully make the tile passable
9917 m.bash( pt, flvel );
9918 thru = m.passable( pt );
9919 } else {
9920 thru = false;
9921 }
9922 }
9923
9924 // If the critter dies during flinging, moving it around causes debugmsgs
9925 if( c->is_dead_state() ) {
9926 return;
9927 }
9928
9929 flvel -= force;
9930 if( thru ) {
9931 if( p != nullptr ) {
9932 if( p->in_vehicle ) {
9933 m.unboard_vehicle( p->pos() );
9934 }
9935 // If we're flinging the player around, make sure the map stays centered on them.
9936 if( is_u && !suppress_map_update ) {
9937 update_map( pt.x, pt.y );
9938 } else {
9939 p->setpos( pt );
9940 }
9941 } else if( !critter_at( pt ) ) {
9942 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
9943 // Just don't setpos if it happens - next iteration will do so
9944 // or the monster will stop a tile before the unpassable one
9945 c->setpos( pt );
9946 }
9947 } else {
9948 // Don't zero flvel - count this as slamming both the obstacle and the ground
9949 // although at lower velocity
9950 break;
9951 }
9952 //Vehicle wall tiles don't count for range
9953 if( !force_next ) {
9954 range--;
9955 }
9956 prev_point = pt;
9957 if( animate && ( seen || u.sees( *c ) ) ) {
9961 }
9962 }
9963
9964 // Fall down to the ground - always on the last reached tile
9965 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
9966 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
9967 // Didn't smash into a wall or a floor so only take the fall damage
9968 if( thru && trap_under_creature == tr_ledge ) {
9969 m.creature_on_trap( *c, false );
9970 } else {
9971 // Fall on ground
9972 int force = rng( flvel, flvel * 2 ) / 9;
9973 if( controlled ) {
9974 force = std::max( force / 2 - 5, 0 );
9975 }
9976 if( force > 0 ) {
9977 int dmg = c->impact( force, c->pos() );
9978 // TODO: Make landing damage the floor
9979 m.bash( c->pos(), dmg / 4, false, false, false );
9980 }
9981 // Always apply traps to creature i.e. bear traps, tele traps etc.
9982 m.creature_on_trap( *c, false );
9983 }
9984 } else {
9985 c->underwater = true;
9986 if( is_u ) {
9987 if( controlled ) {
9988 add_msg( _( "You dive into water." ) );
9989 } else {
9990 add_msg( m_warning, _( "You fall into water." ) );
9991 }
9992 }
9993 }
9994}
void setpos(const tripoint &p) override
Definition: character.h:797
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1839
point update_map(player &p)
Definition: game.cpp:10719
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2446
bool obstructed_by_vehicle_rotation(const tripoint &from, const tripoint &to) const
Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.
Definition: map.cpp:6474
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3508
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1078
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2411
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8460
bool passable(const tripoint &p) const
Definition: map.cpp:1797
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1880
bool is_dead() const
Definition: monster.cpp:2778
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1661
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Definition: ui_manager.cpp:290
int hp
Definition: mtype.h:270
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::obstructed_by_vehicle_rotation(), one_in(), map::passable(), Character::pos(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5101 of file game.cpp.

5102{
5103 // TODO: Z
5104 const int &x = p.x;
5105 const int &y = p.y;
5106 const std::string &door_name = door_type.obj().name();
5107 // sed when player/monsters are knocked back and when moving items out of the way
5108 point kb( x, y );
5109 const auto valid_location = [&]( const tripoint & p ) {
5110 return g->is_empty( p );
5111 };
5113 valid_location ) ) {
5114 kb.x = -pos->x + x + x;
5115 kb.y = -pos->y + y + y;
5116 }
5117 const tripoint kbp( kb, p.z );
5118 if( kbp == p ) {
5119 // can't pushback any creatures anywhere, that means the door can't close.
5120 return false;
5121 }
5122 const bool can_see = u.sees( tripoint( x, y, p.z ) );
5123 player *npc_or_player = critter_at<player>( tripoint( x, y, p.z ), false );
5124 if( npc_or_player != nullptr ) {
5125 if( bash_dmg <= 0 ) {
5126 return false;
5127 }
5128 if( npc_or_player->is_npc() && can_see ) {
5129 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5130 } else if( npc_or_player->is_player() ) {
5131 add_msg( m_bad, _( "The %s hits you." ), door_name );
5132 }
5133 if( npc_or_player->activity ) {
5134 npc_or_player->cancel_activity();
5135 }
5136 // TODO: make the npc angry?
5137 npc_or_player->hitall( bash_dmg, 0, nullptr );
5138 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5139 // TODO: perhaps damage/destroy the gate
5140 // if the npc was really big?
5141 }
5142 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5143 monster &critter = *mon_ptr;
5144 if( bash_dmg <= 0 ) {
5145 return false;
5146 }
5147 if( can_see ) {
5148 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5149 }
5150 if( critter.type->size <= MS_SMALL ) {
5151 critter.die_in_explosion( nullptr );
5152 } else {
5153 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5154 critter.check_dead_state();
5155 }
5156 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5157 // big critters simply prevent the gate from closing
5158 // TODO: perhaps damage/destroy the gate
5159 // if the critter was really big?
5160 return false;
5161 }
5162 if( !critter.is_dead() ) {
5163 // Still alive? Move the critter away so the door can close
5164 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5165 if( critter_at( p ) ) {
5166 return false;
5167 }
5168 }
5169 }
5170 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5171 if( bash_dmg <= 0 ) {
5172 return false;
5173 }
5174 vp->vehicle().damage( vp->part_index(), bash_dmg );
5175 if( m.veh_at( p ) ) {
5176 // Check again in case all parts at the door tile
5177 // have been destroyed, if there is still a vehicle
5178 // there, the door can not be closed
5179 return false;
5180 }
5181 }
5182 if( bash_dmg < 0 && !m.i_at( point( x, y ) ).empty() ) {
5183 return false;
5184 }
5185 if( bash_dmg == 0 ) {
5186 for( auto &elem : m.i_at( point( x, y ) ) ) {
5187 if( elem.made_of( LIQUID ) ) {
5188 // Liquids are OK, will be destroyed later
5189 continue;
5190 } else if( elem.volume() < 250_ml ) {
5191 // Dito for small items, will be moved away
5192 continue;
5193 }
5194 // Everything else prevents the door from closing
5195 return false;
5196 }
5197 }
5198
5199 m.ter_set( point( x, y ), door_type );
5200 if( m.has_flag( "NOITEM", point( x, y ) ) ) {
5201 map_stack items = m.i_at( point( x, y ) );
5202 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5203 if( it->made_of( LIQUID ) ) {
5204 it = items.erase( it );
5205 continue;
5206 }
5207 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5208 if( can_see ) {
5209 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5210 } else {
5211 add_msg( m_warning, _( "Something shatters!" ) );
5212 }
5213 it = items.erase( it );
5214 continue;
5215 }
5216 m.add_item_or_charges( kbp, *it );
5217 it = items.erase( it );
5218 }
5219 }
5220 return true;
5221}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8675
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
Definition: game.cpp:4380
iterator erase(const_iterator it) override
Definition: map.cpp:150
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1636
void die_in_explosion(Creature *source)
Definition: monster.cpp:1675
bool is_npc() const override
Definition: player.h:122
bool is_player() const override
Definition: player.h:105
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:262

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, map::veh_at(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 637 of file game.cpp.

638{
639 return gamemode ? gamemode->id() : SGAME_NULL;
640}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12066 of file game.cpp.

12067{
12068 for( Creature &critter : all_creatures() ) {
12069 if( pred( critter ) ) {
12070 return &critter;
12071 }
12072 }
12073 return nullptr;
12074}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 11976 of file game.cpp.

11978{
11979 std::vector<Creature *> result;
11980 for( Creature &critter : all_creatures() ) {
11981 if( pred( critter ) ) {
11982 result.push_back( &critter );
11983 }
11984 }
11985 return result;
11986}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 11956 of file game.cpp.

11957{
11958 // The player is located in the middle submap of the map.
11960 const tripoint pos_om = sm_to_om_copy( sm );
11961 // TODO: fix point types
11962 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
11963}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8264
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8788 of file game.cpp.

8789{
8790 std::vector<std::string> harmful_stuff;
8791 const auto fields_here = m.field_at( u.pos() );
8792 for( const auto &e : m.field_at( dest_loc ) ) {
8793 // warn before moving into a dangerous field except when already standing within a similar field
8794 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
8795 harmful_stuff.push_back( e.second.name() );
8796 }
8797 }
8798
8799 if( !u.is_blind() ) {
8800 const trap &tr = m.tr_at( dest_loc );
8801 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
8802 true ) );
8803 // HACK: Hack for now, later ledge should stop being a trap
8804 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
8805 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
8806 if( !boardable ) {
8807 harmful_stuff.emplace_back( tr.name() );
8808 }
8809 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
8810 harmful_stuff.emplace_back( tr.name() );
8811 }
8812
8813 static const std::set< body_part > sharp_bps = {
8816 };
8817
8818 const auto sharp_bp_check = [this]( body_part bp ) {
8819 return u.immune_to( bp, { DT_CUT, 10 } );
8820 };
8821
8822 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
8823 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
8824 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
8825 harmful_stuff.emplace_back( m.name( dest_loc ) );
8826 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
8827 m.veh_at( dest_loc ) ) &&
8828 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
8829 harmful_stuff.emplace_back( m.name( dest_loc ) );
8830 }
8831
8832 }
8833
8834 return harmful_stuff;
8835}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:248
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6971
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5279
bool has_zlevels() const
Definition: map.h:1681
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:928
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3739 of file game.cpp.

3740{
3741 // We're going to get the contiguous fishable terrain starting at
3742 // the provided fishing location (e.g. where a line was cast or a fish
3743 // trap was set), and then check whether or not fishable monsters are
3744 // actually in those locations. This will help us ensure that we're
3745 // getting our fish from the location that we're ACTUALLY fishing,
3746 // rather than just somewhere in the vicinity.
3747
3748 std::unordered_set<tripoint> visited;
3749
3750 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3751 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3752
3753 const inclusive_cuboid<tripoint> fishing_boundaries(
3754 fishing_boundary_min, fishing_boundary_max );
3755
3756 const auto get_fishable_terrain = [&]( tripoint starting_point,
3757 std::unordered_set<tripoint> &fishable_terrain ) {
3758 std::queue<tripoint> to_check;
3759 to_check.push( starting_point );
3760 while( !to_check.empty() ) {
3761 const tripoint current_point = to_check.front();
3762 to_check.pop();
3763
3764 // We've been here before, so bail.
3765 if( visited.find( current_point ) != visited.end() ) {
3766 continue;
3767 }
3768
3769 // This point is out of bounds, so bail.
3770 if( !fishing_boundaries.contains( current_point ) ) {
3771 continue;
3772 }
3773
3774 // Mark this point as visited.
3775 visited.emplace( current_point );
3776
3777 if( m.has_flag( "FISHABLE", current_point ) ) {
3778 fishable_terrain.emplace( current_point );
3779 to_check.push( current_point + point_south );
3780 to_check.push( current_point + point_north );
3781 to_check.push( current_point + point_east );
3782 to_check.push( current_point + point_west );
3783 }
3784 }
3785 return;
3786 };
3787
3788 // Starting at the provided location, get our fishable terrain
3789 // and populate a set with those locations which we'll then use
3790 // to determine if any fishable monsters are in those locations.
3791 std::unordered_set<tripoint> fishable_points;
3792 get_fishable_terrain( fish_pos, fishable_points );
3793
3794 return fishable_points;
3795}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 3797 of file game.cpp.

3799{
3800 std::vector<monster *> unique_fish;
3801 for( monster &critter : all_monsters() ) {
3802 // If it is fishable...
3803 if( critter.has_flag( MF_FISHABLE ) ) {
3804 const tripoint critter_pos = critter.pos();
3805 // ...and it is in a fishable location.
3806 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
3807 unique_fish.push_back( &critter );
3808 }
3809 }
3810 }
3811
3812 return unique_fish;
3813}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2060 of file game.cpp.

2061{
2062 return follower_ids;
2063}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 976 of file game.cpp.

977{
978 return *kill_tracker_ptr;
979}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 11941 of file game.cpp.

11942{
11943 return m.get_abs_sub().x;
11944}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 11946 of file game.cpp.

11947{
11948 return m.get_abs_sub().y;
11949}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7180 of file game.cpp.

7181{
7182 return moves_since_last_save;
7183}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 11988 of file game.cpp.

11989{
11990 std::vector<npc *> result;
11991 for( npc &guy : all_npcs() ) {
11992 if( pred( guy ) ) {
11993 result.push_back( &guy );
11994 }
11995 }
11996 return result;
11997}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12076 of file game.cpp.

12077{
12078 return get_world_base_save_path() + "/" + base64_encode( u.name );
12079}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12081

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 238 of file handle_action.cpp.

239{
240 input_context ctxt;
241 if( uquit == QUIT_WATCH ) {
242 ctxt = input_context( "DEFAULTMODE" );
243 ctxt.set_iso( true );
244 // The list of allowed actions in death-cam mode in game::handle_action
245 // *INDENT-OFF*
246 for( const action_id id : {
259 } ) {
260 ctxt.register_action( action_ident( id ) );
261 }
262 // *INDENT-ON*
263 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
264 } else {
266 }
267
269
270 user_turn current_turn;
271
272
273 // Checking early if we will need to handle animations
274 // If we do not need to handle animations that will not change as long as the user has not selected an action
275 // and we can handle it like we are not animating.
276 weather_printable wPrint;
277 bool animate_weather = false;
278 bool animate_sct = false;
279 bool do_animations = [&]() {
280 if( get_option<bool>( "ANIMATIONS" ) ) {
281 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
282
283 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
284 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
285
286#if defined(TILES)
287 // Always animate, minimap and terrain may have animations to run
288 return true;
289#else
290 // Otherwise we need to see if we actually should animate.
291 // Minimap and Terrain never animate in !TILES
292 return animate_weather || animate_sct || uquit == QUIT_WATCH;
293#endif
294 }
295 return false;
296 }
297 ();
298
299 if( do_animations ) {
300 ctxt.set_timeout( 125 );
301
303 make_shared_fast<game::draw_callback_t>( [&]() {
304 if( animate_weather ) {
305 draw_weather( wPrint );
306 }
307 if( animate_sct ) {
308 draw_sct();
309 }
310 } );
311 add_draw_callback( animation_cb );
312 invalidate_main_ui_adaptor(); // We want to redraw at least once.
313
314 do {
315 if( animate_weather ) {
317 generate_weather_anim_frame( get_weather().weather_id, wPrint );
318 }
319 // don't bother calculating SCT if we won't show it
320 if( animate_sct ) {
322
324
325 //Check for creatures on all drawing positions and offset if necessary
326 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
327 const direction oCurDir = iter->getDirecton();
328 const int width = utf8_width( iter->getText() );
329 for( int i = 0; i < width; ++i ) {
330 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
331 const Creature *critter = critter_at( tmp, true );
332
333 if( critter != nullptr && u.sees( *critter ) ) {
334 i = -1;
335 int iPos = iter->getStep() + iter->getStepOffset();
336 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
337 if( iter2->getDirecton() == oCurDir &&
338 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
339 if( iter2->getType() == "hp" ) {
340 iter2->advanceStepOffset();
341 }
342
343 iter2->advanceStepOffset();
344 iPos = iter2->getStep() + iter2->getStepOffset();
345 }
346 }
347 }
348 }
349 }
350
351 // Stop animation when done
352 animate_sct = !SCT.vSCT.empty();
353 }
354 // We don't cache these checks as their result may change after 1st redraw
356 // TODO: we redraw *everything* just to animate a couple blinking dots
357 // on the minimap or a few tiles.
358 // This is far from ideal, and can probably be done much cheaper
359 // (update only part of the screen? draw static parts into a texture?)
361 }
362
363 std::unique_ptr<static_popup> deathcam_msg_popup;
364 if( uquit == QUIT_WATCH ) {
365 deathcam_msg_popup = std::make_unique<static_popup>();
366 deathcam_msg_popup
367 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
368 .on_top( true );
369 }
370
372 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
373 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
374 ctxt.reset_timeout();
375 } else {
378 SCT.vSCT.clear();
379
380 ctxt.set_timeout( 125 );
381 while( handle_mouseview( ctxt, action ) ) {
382 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
383 break;
384 }
385 }
386 ctxt.reset_timeout();
387 }
388
389 return ctxt;
390}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:68
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:257
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1136
bool minimap_requires_animation()
Definition: animation.cpp:1127
void draw_sct()
Definition: animation.cpp:797
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:756
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3152
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2091
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:959
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2191
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1872 of file game.cpp.

1873{
1874 return seed;
1875}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7185 of file game.cpp.

7186{
7187 return user_action_counter;
7188}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3407 of file game.cpp.

3408{
3409 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3410 return cata::nullopt;
3411 }
3412 const optional_vpart_position vp = m.veh_at( u.pos() );
3413 if( !vp ) {
3414 return cata::nullopt;
3415 }
3416 vehicle *const veh = &vp->vehicle();
3417 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3418 float r = 10.0;
3419 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3420}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12081 of file game.cpp.

12082{
12083 if( world_generator->active_world == nullptr ) {
12084 return PATH_INFO::savedir();
12085 }
12086 return world_generator->active_world->folder_path();
12087}
std::string savedir()
Definition: path_info.cpp:250

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7171 of file game.cpp.

7172{
7173#if defined(TILES)
7174 return tileset_zoom;
7175#else
7176 return DEFAULT_TILESET_ZOOM;
7177#endif
7178}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 9591 of file game.cpp.

9592{
9593 // Furniture: pull, push, or standing still and nudging object around.
9594 // Can push furniture out of reach.
9595 tripoint fpos = u.pos() + u.grab_point;
9596 // supposed position of grabbed furniture
9597 if( !m.has_furn( fpos ) ) {
9598 // Where did it go? We're grabbing thin air so reset.
9599 add_msg( m_info, _( "No furniture at grabbed point." ) );
9600 u.grab( OBJECT_NONE );
9601 return false;
9602 }
9603
9604 const bool pushing_furniture = dp == u.grab_point;
9605 const bool pulling_furniture = dp == -u.grab_point;
9606 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
9607
9608 tripoint fdest = fpos + dp; // intended destination of furniture.
9609 // Check floor: floorless tiles don't need to be flat and have no traps
9610 const bool has_floor = m.has_floor( fdest );
9611 // Unfortunately, game::is_empty fails for tiles we're standing on,
9612 // which will forbid pulling, so:
9613 const bool canmove = (
9614 m.passable( fdest ) &&
9615 critter_at<npc>( fdest ) == nullptr &&
9616 critter_at<monster>( fdest ) == nullptr &&
9617 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
9618 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
9619 !m.has_furn( fdest ) &&
9620 !m.veh_at( fdest ) &&
9621 ( !has_floor || m.tr_at( fdest ).is_null() )
9622 );
9623
9624 const furn_t furntype = m.furn( fpos ).obj();
9625 const int src_items = m.i_at( fpos ).size();
9626 const int dst_items = m.i_at( fdest ).size();
9627
9628 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
9629 [&]( item & liquid_item ) {
9630 return liquid_item.made_of( LIQUID );
9631 } );
9632
9633 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
9634 !m.has_flag( "SWIMMABLE", fdest ) &&
9635 !m.has_flag( "DESTROY_ITEM", fdest );
9636
9637 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
9638 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
9639 m.furn( fpos ).obj().has_flag( "SEALED" );
9640
9641 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
9642 time_duration fire_age = m.get_field_age( fpos, fd_fire );
9643
9644 int str_req = furntype.move_str_req;
9645 // Factor in weight of items contained in the furniture.
9646 units::mass furniture_contents_weight = 0_gram;
9647 for( auto &contained_item : m.i_at( fpos ) ) {
9648 furniture_contents_weight += contained_item.weight();
9649 }
9650 str_req += furniture_contents_weight / 4_kilogram;
9651 if( !canmove ) {
9652 // TODO: What is something?
9653 add_msg( _( "The %s collides with something." ), furntype.name() );
9654 u.moves -= 50;
9655 return true;
9656 ///\EFFECT_STR determines ability to drag furniture
9657 } else if( str_req > u.get_str() &&
9658 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
9659 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
9660 furntype.name() );
9661 u.moves -= 100;
9662 u.mod_pain( 1 ); // Hurt ourselves.
9663 return true; // furniture and or obstacle wins.
9664 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
9665 add_msg( _( "There's stuff in the way." ) );
9666 u.moves -= 50;
9667 return true;
9668 }
9669
9670 u.moves -= str_req * 10;
9671 // Additional penalty if we can't comfortably move it.
9672 if( str_req > u.get_str() ) {
9673 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
9674 if( move_penalty <= 1000 ) {
9675 if( u.get_str() >= str_req - 3 ) {
9676 u.moves -= std::max( 3000, move_penalty * 10 );
9677 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
9678 if( one_in( 3 ) ) {
9679 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
9680 return true;
9681 }
9682 } else {
9683 u.moves -= 100;
9684 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
9685 return true;
9686 }
9687 }
9688 u.moves -= move_penalty;
9689 if( move_penalty > 500 ) {
9690 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
9691 furntype.name() );
9692 } else if( move_penalty > 200 ) {
9693 if( one_in( 3 ) ) { // Nag only occasionally.
9694 add_msg( _( "It takes some time to move the heavy %s." ),
9695 furntype.name() );
9696 }
9697 }
9698 }
9700 _( "a scraping noise." ), true, "misc", "scraping" );
9701
9703 ( tripoint_abs_ms( m.getabs( fpos ) ) );
9704
9705 // Actually move the furniture.
9706 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
9707 m.furn_set( fpos, f_null );
9708
9709 if( fire_intensity == 1 && !pulling_furniture ) {
9710 m.remove_field( fpos, fd_fire );
9711 m.set_field_intensity( fdest, fd_fire, fire_intensity );
9712 m.set_field_age( fdest, fd_fire, fire_age );
9713 }
9714
9715 // Is there is only liquids on the ground, remove them after moving furniture.
9716 if( dst_items > 0 && only_liquid_items ) {
9717 m.i_clear( fdest );
9718 }
9719
9720 if( src_items > 0 ) { // Move the stuff inside.
9721 if( dst_item_ok && src_item_ok ) {
9722 // Assume contents of both cells are legal, so we can just swap contents.
9723 std::list<item> temp;
9724 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
9725 std::back_inserter( temp ) );
9726 m.i_clear( fpos );
9727 for( auto item_iter = m.i_at( fdest ).begin();
9728 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
9729 m.i_at( fpos ).insert( *item_iter );
9730 }
9731 m.i_clear( fdest );
9732 for( auto &cur_item : temp ) {
9733 m.i_at( fdest ).insert( cur_item );
9734 }
9735 } else {
9736 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
9737 }
9738 }
9739
9740 if( shifting_furniture ) {
9741 // We didn't move
9742 tripoint d_sum = u.grab_point + dp;
9743 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
9744 u.grab_point = d_sum; // furniture moved relative to us
9745 } else { // we pushed furniture out of reach
9746 add_msg( _( "You let go of the %s." ), furntype.name() );
9747 u.grab( OBJECT_NONE );
9748 }
9749 return true; // We moved furniture but stayed still.
9750 }
9751
9752 if( pushing_furniture && m.impassable( fpos ) ) {
9753 // Not sure how that chair got into a wall, but don't let player follow.
9754 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
9755 furntype.name(), m.tername( fdest ) );
9756 u.grab( OBJECT_NONE );
9757 return true;
9758 }
9759
9760 return false;
9761}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4064
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:653
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:4955
void insert(const item &newitem) override
Definition: map.cpp:155
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5445
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5319
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5353
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5359
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5332
std::string tername(const tripoint &p) const
Definition: map.cpp:1706
void i_clear(const tripoint &p)
Definition: map.cpp:4109
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1357
bool has_floor(const tripoint &p) const
Definition: map.cpp:2004
tripoint grab_point
Definition: player.h:589
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:511
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 9763 of file game.cpp.

9764{
9765 if( u.get_grab_type() == OBJECT_NONE ) {
9766 return false;
9767 }
9768
9769 if( dp.z != 0 ) {
9770 // No dragging stuff up/down stairs yet!
9771 return false;
9772 }
9773
9774 // vehicle: pulling, pushing, or moving around the grabbed object.
9775 if( u.get_grab_type() == OBJECT_VEHICLE ) {
9776 return grabbed_veh_move( dp );
9777 }
9778
9779 if( u.get_grab_type() == OBJECT_FURNITURE ) {
9780 return grabbed_furn_move( dp );
9781 }
9782
9783 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
9785 u.grab( OBJECT_NONE );
9786 return false;
9787}
object_type get_grab_type() const
Definition: avatar.cpp:661
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:9591
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150
151 // Grabbed part has to stay at distance 1 to the player
152 // and in roughly the same direction.
153 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
154 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
155 const tripoint expected_pos = u.pos() + dp + from;
156 const tripoint actual_dir = expected_pos - new_part_pos;
157
158 grabbed_vehicle->adjust_zlevel( 1, dp );
159
160 // Set player location to illegal value so it can't collide with vehicle.
161 const tripoint player_prev = u.pos();
163 std::vector<veh_collision> colls;
164 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
165 u.setpos( player_prev );
166 if( !colls.empty() ) {
167 blocker_name = colls.front().target_name;
168 }
169 return failed ? tripoint_zero : actual_dir;
170 };
171
172 // First try the move as intended
173 // But if that fails and the move is a zig-zag, try to recover:
174 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
175 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
176 if( final_dp_veh == tripoint_zero && zigzag ) {
177 final_dp_veh = get_move_dir( -prev_grab, -dp );
178 next_grab = -dp;
179 }
180
181 if( final_dp_veh == tripoint_zero ) {
182 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
183 u.grab_point = prev_grab;
184 return true;
185 }
186
187 u.grab_point = next_grab;
188
189 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
190
191 if( grabbed_vehicle ) {
192 grabbed_vehicle->shift_zlevel();
193 grabbed_vehicle->check_falling_or_floating();
194 } else {
195 debugmsg( "Grabbed vehicle disappeared" );
196 return false;
197 }
198
199 for( int p : wheel_indices ) {
200 if( one_in( 2 ) ) {
201 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
202 grabbed_vehicle->handle_trap( wheel_p, p );
203 }
204 }
205
206 return false;
207
208}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1116
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1777
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5826
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3281
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3150
bool valid_wheel_config() const
Definition: vehicle.cpp:4459
units::mass total_mass() const
Definition: vehicle.cpp:3306
std::vector< int > wheelcache
Definition: vehicle.h:1818
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1948
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6968
int part_count() const
Definition: vehicle.cpp:7075
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3262
vehicle_part & part(int part_num)
Definition: vehicle.cpp:7080
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3286
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1927
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1514 of file handle_action.cpp.

1515{
1516 std::string action;
1517 input_context ctxt;
1519 user_turn current_turn;
1520 // Check if we have an auto-move destination
1521 if( u.has_destination() ) {
1523 if( act == ACTION_NULL ) {
1524 add_msg( m_info, _( "Auto-move canceled" ) );
1526 return false;
1527 }
1528 } else if( u.has_destination_activity() ) {
1529 // starts destination activity after the player successfully reached his destination
1531 return false;
1532 } else {
1533 // No auto-move, ask player for input
1534 ctxt = get_player_input( action );
1535 }
1536
1537 const optional_vpart_position vp = m.veh_at( u.pos() );
1538 bool veh_ctrl = !u.is_dead_state() &&
1539 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1540
1541 // If performing an action with right mouse button, co-ordinates
1542 // of location clicked.
1543 cata::optional<tripoint> mouse_target;
1544
1545 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1546 uquit = QUIT_DIED;
1547 return false;
1548 }
1549
1550 if( act == ACTION_NULL ) {
1552
1553 if( act == ACTION_KEYBINDINGS ) {
1554 // already handled by input context
1555 return false;
1556 }
1557
1558 if( act == ACTION_MAIN_MENU ) {
1559 if( uquit == QUIT_WATCH ) {
1560 return false;
1561 }
1562 // No auto-move actions have or can be set at this point.
1564 destination_preview.clear();
1566 if( act == ACTION_NULL ) {
1567 return false;
1568 }
1569 }
1570
1571 if( act == ACTION_ACTIONMENU ) {
1572 if( uquit == QUIT_WATCH ) {
1573 return false;
1574 }
1575 // No auto-move actions have or can be set at this point.
1577 destination_preview.clear();
1579 if( act == ACTION_NULL ) {
1580 return false;
1581 }
1582#if defined(__ANDROID__)
1583 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1584 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1585 }
1586#endif
1587 }
1588
1589 if( act == ACTION_KEYBINDINGS ) {
1591 destination_preview.clear();
1592 act = ctxt.display_menu( true );
1593 if( act == ACTION_NULL ) {
1594 return false;
1595 }
1596 }
1597
1600 }
1601
1602 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1603 // Mouse button click
1604 if( veh_ctrl ) {
1605 // No mouse use in vehicle
1606 return false;
1607 }
1608
1609 if( u.is_dead_state() ) {
1610 // do not allow mouse actions while dead
1611 return false;
1612 }
1613
1614 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1615 if( !mouse_pos ) {
1616 return false;
1617 } else if( !u.sees( *mouse_pos ) ) {
1618 // Not clicked in visible terrain
1619 return false;
1620 }
1621 mouse_target = mouse_pos;
1622
1623 if( act == ACTION_SELECT ) {
1624 // Note: The following has the potential side effect of
1625 // setting auto-move destination state in addition to setting
1626 // act.
1627 if( !try_get_left_click_action( act, *mouse_target ) ) {
1628 return false;
1629 }
1630 } else if( act == ACTION_SEC_SELECT ) {
1631 if( !try_get_right_click_action( act, *mouse_target ) ) {
1632 return false;
1633 }
1634 }
1635 } else if( act != ACTION_TIMEOUT ) {
1636 // act has not been set for an auto-move, so clearing possible
1637 // auto-move destinations. Since initializing an auto-move with
1638 // the mouse may span across multiple actions, we do not clear the
1639 // auto-move destination if the action is only a timeout, as this
1640 // would require the user to double click quicker than the
1641 // timeout delay.
1643 destination_preview.clear();
1644 }
1645 }
1646
1647 if( act == ACTION_NULL ) {
1648 const input_event &&evt = ctxt.get_raw_input();
1649 if( !evt.sequence.empty() ) {
1650 const int ch = evt.get_first_input();
1651 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1652 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1653 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1654 if( const cata::optional<std::string> hint =
1656 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1657 "the current context." ),
1658 *hint );
1659 }
1660 }
1661 }
1662 return false;
1663 }
1664
1665 // This has no action unless we're in a special game mode.
1666 gamemode->pre_action( act );
1667
1668 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1669
1670 int before_action_moves = u.moves;
1671
1672 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1673 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1674 switch( act ) {
1677 break;
1678
1679 case ACTION_CENTER:
1682 break;
1683
1684 case ACTION_SHIFT_N:
1685 case ACTION_SHIFT_NE:
1686 case ACTION_SHIFT_E:
1687 case ACTION_SHIFT_SE:
1688 case ACTION_SHIFT_S:
1689 case ACTION_SHIFT_SW:
1690 case ACTION_SHIFT_W:
1691 case ACTION_SHIFT_NW: {
1692 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1701 };
1703 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1704 }
1705 break;
1706
1707 case ACTION_LOOK:
1708 look_around();
1709 break;
1710
1711 case ACTION_KEYBINDINGS:
1712 // already handled by input context
1713 break;
1714
1715 default:
1716 break;
1717 }
1718 }
1719
1720 // actions allowed only while alive
1721 if( !u.is_dead_state() ) {
1722 switch( act ) {
1723 case ACTION_NULL:
1724 case NUM_ACTIONS:
1725 break; // dummy entries
1726 case ACTION_ACTIONMENU:
1727 case ACTION_MAIN_MENU:
1728 case ACTION_KEYBINDINGS:
1729 break; // handled above
1730
1731 case ACTION_TIMEOUT:
1732 if( check_safe_mode_allowed( false ) ) {
1733 u.pause();
1734 }
1735 break;
1736
1737 case ACTION_PAUSE:
1738 if( check_safe_mode_allowed() ) {
1739 u.pause();
1740 }
1741 break;
1742
1743 case ACTION_CYCLE_MOVE:
1745 break;
1746
1747 case ACTION_RESET_MOVE:
1749 break;
1750
1751 case ACTION_TOGGLE_RUN:
1753 break;
1754
1757 break;
1758
1761 break;
1762
1763 case ACTION_MOVE_FORTH:
1765 case ACTION_MOVE_RIGHT:
1767 case ACTION_MOVE_BACK:
1769 case ACTION_MOVE_LEFT:
1771 if( !u.get_value( "remote_controlling" ).empty() &&
1775 } else if( veh_ctrl ) {
1776 // vehicle control uses x for steering and y for ac/deceleration,
1777 // so no rotation needed
1779 } else {
1781 if( auto_travel_mode && !u.is_auto_moving() ) {
1782 for( int i = 0; i < SEEX; i++ ) {
1783 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1784 u.posy() + dest_delta.y * ( SEEX - i ),
1785 u.posz() );
1787 auto_travel_destination,
1789 u.get_path_avoid() );
1790 if( !destination_preview.empty() ) {
1793 break;
1794 }
1795 }
1798 if( dest_next == point_zero ) {
1800 }
1801 dest_delta = dest_next;
1802 }
1803 if( !avatar_action::move( u, m, dest_delta ) ) {
1804 // auto-move should be canceled due to a failed move or obstacle
1806 }
1807 }
1808 break;
1809 case ACTION_MOVE_DOWN:
1810 if( u.is_mounted() ) {
1811 auto mon = u.mounted_creature.get();
1812 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1813 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1814 break;
1815 }
1816 }
1817 if( !u.in_vehicle ) {
1818 vertical_move( -1, false );
1819 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1821 }
1822 break;
1823
1824 case ACTION_MOVE_UP:
1825 if( u.is_mounted() ) {
1826 auto mon = u.mounted_creature.get();
1827 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1828 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1829 break;
1830 }
1831 }
1832 if( !u.in_vehicle ) {
1833 vertical_move( 1, false );
1834 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1836 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1837 !vp->vehicle().has_sufficient_rotorlift() ) {
1838 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1839 }
1840 break;
1841
1842 case ACTION_OPEN:
1844 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1845 } else if( u.is_mounted() ) {
1846 add_msg( m_info, _( "You can't open things while you're riding." ) );
1847 } else {
1848 open();
1849 }
1850 break;
1851
1852 case ACTION_CLOSE:
1854 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1855 } else if( u.is_mounted() ) {
1856 auto mon = u.mounted_creature.get();
1857 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1858 add_msg( m_info, _( "You can't close things while you're riding." ) );
1859 }
1860 } else if( mouse_target ) {
1861 doors::close_door( m, u, *mouse_target );
1862 } else {
1863 close();
1864 }
1865 break;
1866
1867 case ACTION_SMASH:
1868 if( veh_ctrl ) {
1869 handbrake();
1870 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1871 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1872 } else {
1873 smash();
1874 }
1875 break;
1876
1877 case ACTION_EXAMINE:
1879 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1880 } else if( mouse_target ) {
1881 examine( *mouse_target );
1882 } else {
1883 examine();
1884 }
1885 break;
1886
1887 case ACTION_ADVANCEDINV:
1889 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1890 } else if( u.is_mounted() ) {
1891 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1892 } else {
1894 }
1895 break;
1896
1897 case ACTION_PICKUP:
1899 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1900 } else if( u.is_mounted() ) {
1901 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1902 } else if( mouse_target ) {
1903 pickup( *mouse_target );
1904 } else {
1905 pickup();
1906 }
1907 break;
1908
1909 case ACTION_PICKUP_FEET:
1911 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1912 } else {
1913 pickup_feet();
1914 }
1915 break;
1916
1917 case ACTION_GRAB:
1919 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1920 } else if( u.is_mounted() ) {
1921 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1922 } else {
1923 grab();
1924 }
1925 break;
1926
1927 case ACTION_HAUL:
1929 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1930 } else if( u.is_mounted() ) {
1931 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1932 } else {
1933 haul();
1934 }
1935 break;
1936
1937 case ACTION_BUTCHER:
1939 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1940 } else if( u.is_mounted() ) {
1941 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1942 } else {
1943 butcher();
1944 }
1945 break;
1946
1947 case ACTION_CHAT:
1948 chat();
1949 break;
1950
1951 case ACTION_PEEK:
1953 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1954 } else if( u.is_mounted() ) {
1955 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1956 } else {
1957 peek();
1958 }
1959 break;
1960
1961 case ACTION_LIST_ITEMS:
1963 break;
1964
1965 case ACTION_ZONES:
1966 zones_manager();
1967 break;
1968
1969 case ACTION_LOOT:
1970 loot();
1971 break;
1972
1973 case ACTION_INVENTORY:
1975 break;
1976
1977 case ACTION_COMPARE:
1979 break;
1980
1981 case ACTION_ORGANIZE:
1983 break;
1984
1985 case ACTION_USE:
1986 // Shell-users are presumed to be able to mess with their inventories, etc
1987 // while in the shell. Eating, gear-changing, and item use are OK.
1989 break;
1990
1991 case ACTION_USE_WIELDED:
1992 u.use_wielded();
1993 break;
1994
1995 case ACTION_WEAR:
1996 wear();
1997 break;
1998
1999 case ACTION_TAKE_OFF:
2000 takeoff();
2001 break;
2002
2003 case ACTION_EAT:
2004 if( !avatar_action::eat_here( u ) ) {
2006 }
2007 break;
2008
2010 if( !avatar_action::eat_here( u ) ) {
2012 }
2013 break;
2014
2015 case ACTION_READ:
2016 // Shell-users are presumed to have the book just at an opening and read it that way
2017 read();
2018 break;
2019
2020 case ACTION_WIELD:
2022 break;
2023
2024 case ACTION_PICK_STYLE:
2025 u.martial_arts_data->pick_style( u );
2026 break;
2027
2028 case ACTION_RELOAD_ITEM:
2030 break;
2031
2034 break;
2035
2038 break;
2039
2040 case ACTION_UNLOAD:
2042 break;
2043
2044 case ACTION_MEND:
2046 break;
2047
2048 case ACTION_THROW: {
2049 item_location loc;
2050 avatar_action::plthrow( g->u, loc );
2051 break;
2052 }
2053
2054 case ACTION_FIRE:
2055 fire();
2056 break;
2057
2058 case ACTION_CAST_SPELL:
2059 cast_spell();
2060 break;
2061
2062 case ACTION_FIRE_BURST: {
2063 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2065 }
2066 break;
2067 }
2068
2070 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2071 if( u.weapon.gun_all_modes().size() > 1 ) {
2073 } else {
2074 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2075 }
2076 }
2077 break;
2078
2080 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2082 }
2083 break;
2084
2085 case ACTION_DROP:
2086 // You CAN drop things to your own tile while in the shell.
2087 drop();
2088 break;
2089
2090 case ACTION_DIR_DROP:
2092 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2093 } else {
2095 }
2096 break;
2097 case ACTION_BIONICS:
2098 u.power_bionics();
2099 break;
2100 case ACTION_MUTATIONS:
2102 break;
2103
2104 case ACTION_SORT_ARMOR:
2105 u.sort_armor();
2106 break;
2107
2108 case ACTION_WAIT:
2109 wait();
2110 break;
2111
2112 case ACTION_CRAFT:
2114 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2115 } else if( u.is_mounted() ) {
2116 add_msg( m_info, _( "You can't craft while you're riding." ) );
2117 } else {
2118 u.craft();
2119 }
2120 break;
2121
2122 case ACTION_RECRAFT:
2124 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2125 } else if( u.is_mounted() ) {
2126 add_msg( m_info, _( "You can't craft while you're riding." ) );
2127 } else {
2128 u.recraft();
2129 }
2130 break;
2131
2132 case ACTION_LONGCRAFT:
2134 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2135 } else if( u.is_mounted() ) {
2136 add_msg( m_info, _( "You can't craft while you're riding." ) );
2137 } else {
2138 u.long_craft();
2139 }
2140 break;
2141
2142 case ACTION_DISASSEMBLE:
2143 if( u.controlling_vehicle ) {
2144 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2145 } else if( u.is_mounted() ) {
2146 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2147 } else {
2149 }
2150 break;
2151
2152 case ACTION_CONSTRUCT:
2153 if( u.in_vehicle ) {
2154 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2155 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2156 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2157 } else if( u.is_mounted() ) {
2158 add_msg( m_info, _( "You can't construct while you're riding." ) );
2159 } else {
2160 construction_menu( false );
2161 }
2162 break;
2163
2164 case ACTION_SLEEP:
2165 if( veh_ctrl ) {
2166 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2167 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2168 _( "new default binding is '^'." ) ) );
2169 } else {
2170 sleep();
2171 }
2172 break;
2173
2176 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2177 } else if( u.is_mounted() ) {
2178 u.dismount();
2179 } else {
2181 }
2182 break;
2183
2186 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2187 break;
2188
2190 if( safe_mode == SAFE_MODE_OFF ) {
2192 mostseen = 0;
2193 add_msg( m_info, _( "Safe mode ON!" ) );
2194 } else {
2197 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2198 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2199 }
2203 }
2204 break;
2205
2207 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2208 add_msg( m_info, autosafemode_option.value_as<bool>()
2209 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2210 autosafemode_option.setNext();
2211 break;
2212 }
2213
2215 if( safe_mode == SAFE_MODE_STOP ) {
2216 add_msg( m_info, _( "Ignoring enemy!" ) );
2217 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2218 monster &critter = *elem;
2219 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2220 }
2222 } else if( u.has_effect( effect_laserlocked ) ) {
2223 if( u.has_trait( trait_PROF_CHURL ) ) {
2224 add_msg( m_warning, _( "You make the sign of the cross." ) );
2225 } else {
2226 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2227 }
2230 }
2231 break;
2232
2234 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2236 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2238 mostseen = 0;
2239 } else {
2240 get_safemode().show();
2241 }
2242 break;
2243
2244 case ACTION_SUICIDE:
2245 if( query_yn( _( "Commit suicide?" ) ) ) {
2246 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2247 u.moves = 0;
2248 u.place_corpse();
2250 }
2251 }
2252 break;
2253
2254 case ACTION_SAVE:
2255 if( query_yn( _( "Save and quit?" ) ) ) {
2256 if( save() ) {
2257 u.moves = 0;
2258 uquit = QUIT_SAVED;
2259 }
2260 }
2261 break;
2262
2263 case ACTION_QUICKSAVE:
2264 quicksave();
2265 return false;
2266
2267 case ACTION_QUICKLOAD:
2268 quickload();
2269 return false;
2270
2271 case ACTION_PL_INFO:
2273 break;
2274
2275 case ACTION_MAP:
2277 break;
2278
2279 case ACTION_SKY:
2280 if( m.is_outside( u.pos() ) ) {
2282 } else {
2283 add_msg( m_info, _( "You can't see the sky from here." ) );
2284 }
2285 break;
2286
2287 case ACTION_MISSIONS:
2288 list_missions();
2289 break;
2290
2291 case ACTION_SCORES:
2293 break;
2294
2295 case ACTION_FACTIONS:
2296 faction_manager_ptr->display();
2297 break;
2298
2299 case ACTION_MORALE:
2300 u.disp_morale();
2301 break;
2302
2303 case ACTION_MESSAGES:
2305 break;
2306
2307 case ACTION_HELP:
2309 break;
2310
2311 case ACTION_OPTIONS:
2312 get_options().show( true );
2313 break;
2314
2315 case ACTION_AUTOPICKUP:
2317 break;
2318
2319 case ACTION_AUTONOTES:
2321 break;
2322
2323 case ACTION_SAFEMODE:
2324 get_safemode().show();
2325 break;
2326
2327 case ACTION_COLOR:
2328 all_colors.show_gui();
2329 break;
2330
2331 case ACTION_WORLD_MODS:
2332 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2333 break;
2334
2335 case ACTION_DEBUG:
2337 break; //don't do anything when sharing and not debugger
2338 }
2340 break;
2341
2344 break;
2345
2348 break;
2349
2352 break;
2353
2356 break;
2357
2359 get_options().get_option( "AUTO_FEATURES" ).setNext();
2360 get_options().save();
2361 //~ Auto Features are now ON/OFF
2362 add_msg( _( "%s are now %s." ),
2363 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2364 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2365 break;
2366
2368 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2369 get_options().save();
2370 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2371 add_msg( _( "%s is now set to %s." ),
2372 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2373 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2374 break;
2375
2377 get_options().get_option( "AUTO_MINING" ).setNext();
2378 get_options().save();
2379 //~ Auto Mining is now ON/OFF
2380 add_msg( _( "%s is now %s." ),
2381 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2382 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2383 break;
2384
2386 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2387 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2388 u.set_value( "THIEF_MODE_KEEP", "YES" );
2389 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2390 add_msg( _( "You will not pick up other peoples belongings." ) );
2391 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2392 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2393 u.set_value( "THIEF_MODE_KEEP", "YES" );
2394 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2395 add_msg( _( "You will pick up also those things that belong to others!" ) );
2396 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2397 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2398 u.set_value( "THIEF_MODE_KEEP", "NO" );
2399 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2400 add_msg( _( "You will be reminded not to steal." ) );
2401 } else {
2402 // ERROR
2403 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2404 }
2405 break;
2406
2408 get_options().get_option( "AUTO_FORAGING" ).setNext();
2409 get_options().save();
2410 //~ Auto Foraging is now set to x
2411 add_msg( _( "%s is now set to %s." ),
2412 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2413 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2414 break;
2415
2417 get_options().get_option( "AUTO_PICKUP" ).setNext();
2418 get_options().save();
2419 //~ Auto pickup is now set to x
2420 add_msg( _( "%s is now set to %s." ),
2421 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2422 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2423 break;
2424
2427 break; //don't do anything when sharing and not debugger
2428 }
2429 display_scent();
2430 break;
2431
2434 break; //don't do anything when sharing and not debugger
2435 }
2436 display_scent();
2437 break;
2438
2441 break; //don't do anything when sharing and not debugger
2442 }
2444 break;
2447 break; //don't do anything when sharing and not debugger
2448 }
2450 break;
2453 break; //don't do anything when sharing and not debugger
2454 }
2456 break;
2457
2460 break; //don't do anything when sharing and not debugger
2461 }
2463 break;
2464
2467 break; //don't do anything when sharing and not debugger
2468 }
2470 break;
2471
2474 break; //don't do anything when sharing and not debugger
2475 }
2477 break;
2478
2480 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2481 break;
2482
2485 break;
2486
2489 break; //don't do anything when sharing and not debugger
2490 }
2492 if( debug_mode ) {
2493 add_msg( m_info, _( "Debug mode ON!" ) );
2494 } else {
2495 add_msg( m_info, _( "Debug mode OFF!" ) );
2496 }
2497 break;
2498
2499 case ACTION_ZOOM_IN:
2500 zoom_in();
2502 break;
2503
2504 case ACTION_ZOOM_OUT:
2505 zoom_out();
2507 break;
2508
2509 case ACTION_ITEMACTION:
2511 break;
2512
2513 case ACTION_AUTOATTACK:
2515 break;
2516
2517 default:
2518 break;
2519 }
2520 }
2521 if( act != ACTION_TIMEOUT ) {
2522 u.mod_moves( -current_turn.moves_elapsed() );
2523 }
2524 gamemode->post_action( act );
2525
2526 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2527 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2528 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2529 return ( !u.is_dead_state() );
2530}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:469
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:348
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:418
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:941
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:507
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:655
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:265
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:259
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:263
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:267
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:261
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:269
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
bool tile_iso
Using isometric tileset.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1525
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2561
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9946
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9960
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1247
item weapon
Definition: character.h:1521
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1331
std::string get_value(const std::string &key) const
Definition: creature.cpp:1341
void mod_moves(int nmoves)
Definition: creature.cpp:1408
void cycle_move_mode()
Definition: avatar.cpp:1170
void toggle_map_memory()
Definition: avatar.cpp:119
void toggle_crouch_mode()
Definition: avatar.cpp:1154
void toggle_run_mode()
Definition: avatar.cpp:1145
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:985
void reset_move_mode()
Definition: avatar.cpp:1163
void item_action_menu()
void display_radiation()
Definition: game.cpp:11319
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2384
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:8698
cata::optional< tripoint > look_around()
Definition: game.cpp:6654
void pickup_feet()
Definition: game.cpp:5711
void zones_manager()
Definition: game.cpp:6179
int turnssincelastmon
Definition: game.h:1042
void display_visibility()
Definition: game.cpp:11233
void display_scent()
Definition: game.cpp:11198
bool save()
Returns false if saving failed.
Definition: game.cpp:2877
void butcher()
Definition: game.cpp:8380
void display_temperature()
Definition: game.cpp:11219
bool auto_travel_mode
Definition: game.h:1039
void zoom_out()
Definition: game.cpp:7127
void toggle_pixel_minimap()
Definition: game.cpp:513
void toggle_debug_hour_timer()
Definition: game.cpp:11265
void display_transparency()
Definition: game.cpp:11326
void list_items_monsters()
Definition: game.cpp:7304
void chat()
Definition: npctalk.cpp:394
void quickload()
Definition: game.cpp:11361
void pickup()
Definition: game.cpp:5689
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10046
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11293
void control_vehicle()
Definition: game.cpp:5259
void peek()
Definition: game.cpp:5718
void drop()
Definition: game.cpp:8118
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2412
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:8636
void zoom_in()
Definition: game.cpp:7139
void toggle_fullscreen()
Definition: game.cpp:503
void display_vehicle_ai()
Definition: game.cpp:11226
void reload_tileset()
Definition: game.cpp:524
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3125
void drop_in_direction()
Definition: game.cpp:8123
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6388
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7779
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4727
bool is_gunmod() const
Definition: item.cpp:6418
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7698
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7770
bool is_outside(const tripoint &p) const
Definition: map.cpp:2560
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:256
short ignoring
Definition: monster.h:508
cOpt & get_option(const std::string &name)
Definition: options.cpp:3357
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2740
void show_adm()
Definition: panels.cpp:2406
void pause()
Definition: player.cpp:609
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:340
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3058
int movecounter
Definition: player.h:601
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:351
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:360
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
cata::optional< construction_id > construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void reload_wielded(bool prompt=false)
Reload wielded item.
void reload_item()
Prompt to reload some item.
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void wield()
Prompt to wield some item.
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void reload_weapon(bool try_everything=true)
Reload a wielded gun/tool.
void mend(avatar &you, item_location loc)
void unload(avatar &you)
Prompts to unload some item.
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3754
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, auto_travel_mode, avatar_action::autoattack(), bio_remote, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, crafting::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), avatar_action::reload_item(), reload_tileset(), avatar_action::reload_weapon(), avatar_action::reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), avatar_action::wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2065 of file game.cpp.

2066{
2068 const std::string action = ctxt.handle_input( 0 );
2069 bool refresh = true;
2070 if( action == "pause" ) {
2072 cancel_activity_query( _( "Confirm:" ) );
2073 }
2074 } else if( action == "player_data" ) {
2076 } else if( action == "messages" ) {
2078 } else if( action == "help" ) {
2080 } else if( action != "HELP_KEYBINDINGS" ) {
2081 refresh = false;
2082 }
2083 if( refresh ) {
2086 }
2087}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1849
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2091 of file game.cpp.

2092{
2093 cata::optional<tripoint> liveview_pos;
2094
2095 do {
2096 action = ctxt.handle_input();
2097 if( action == "MOUSE_MOVE" ) {
2098 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2099 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2100 liveview_pos = mouse_pos;
2101 liveview.show( *liveview_pos );
2102 } else if( !mouse_pos ) {
2103 liveview_pos.reset();
2104 liveview.hide();
2105 }
2107 }
2108 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2109
2110 if( action != "TIMEOUT" ) {
2111 // Keyboard event, break out of animation loop
2112 liveview.hide();
2113 return false;
2114 }
2115
2116 // Mouse movement or un-handled key
2117 return true;
2118}
void reset() noexcept
Definition: optional.h:158
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 632 of file game.cpp.

633{
634 return gamemode && gamemode->id() != SGAME_NULL;
635}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11333 of file game.cpp.

11334{
11336 last_save_timestamp = time( nullptr );
11337}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 397 of file game_inventory.cpp.

399{
401 title, radius, none_message );
402}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:330

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 436 of file game.cpp.

437{
439}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8766 of file game.cpp.

8767{
8768 return !( get_dangerous_tile( dest_loc ).empty() );
8769}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8788

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 4955 of file game.cpp.

4956{
4957 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
4958 critter_at( p ) == nullptr;
4959}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2457 of file game.cpp.

2458{
2459 if( uquit == QUIT_WATCH ) {
2460 // deny player movement and dodging
2461 u.moves = 0;
2462 // prevent pain from updating
2463 u.set_pain( 0 );
2464 // prevent dodging
2465 u.dodges_left = 0;
2466 return false;
2467 }
2468 if( uquit == QUIT_DIED ) {
2469 if( u.in_vehicle ) {
2470 m.unboard_vehicle( u.pos() );
2471 }
2472 u.place_corpse();
2473 return true;
2474 }
2475 if( uquit == QUIT_SUICIDE ) {
2476 if( u.in_vehicle ) {
2477 m.unboard_vehicle( u.pos() );
2478 }
2479 return true;
2480 }
2481 if( uquit != QUIT_NO ) {
2482 return true;
2483 }
2484 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2485 if( u.is_dead_state() ) {
2487 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2488 uquit = QUIT_WATCH;
2489 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2490 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2492 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2493 uquit = QUIT_DIED;
2494 } else {
2495 // Something funky happened here, just die.
2496 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2497 uquit = QUIT_DIED;
2498 }
2499 return is_game_over();
2500 }
2501 return false;
2502}
int dodges_left
Definition: character.h:559
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:972
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:192
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3716 of file game.cpp.

3717{
3718 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3719 get_option<int>( "SAFEMODEPROXIMITY" );
3720 return is_hostile_within( distance );
3721}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3728

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3723 of file game.cpp.

3724{
3726}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:194

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3728 of file game.cpp.

3729{
3730 for( auto &critter : u.get_visible_creatures( distance ) ) {
3731 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3732 return critter;
3733 }
3734 }
3735
3736 return nullptr;
3737}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 4961 of file game.cpp.

4962{
4963 return weather::is_in_sunlight( m, p, get_weather().weather_id );
4964}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3362 of file game.cpp.

3363{
3364 const tripoint diff( u.pos() + u.view_offset - p );
3365
3366 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3367 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3368}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 4966 of file game.cpp.

4967{
4968 return weather::is_sheltered( m, p );
4969}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6109 of file game.cpp.

6110{
6111 return zones_manager_open;
6112}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1074

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1519
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1239
void restack(player &p)
Definition: inventory.cpp:398
void unsort()
Definition: inventory.cpp:226
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult 
)

Definition at line 4380 of file game.cpp.

4381{
4382 std::vector<tripoint> traj;
4383 traj.clear();
4384 traj = line_to( s, t, 0, 0 );
4385 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4386 traj = continue_line( traj, force );
4387 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4388
4389 knockback( traj, stun, dam_mult );
4390}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult 
)

Definition at line 4396 of file game.cpp.

4397{
4398 // TODO: make the force parameter actually do something.
4399 // the header file says higher force causes more damage.
4400 // perhaps that is what it should do?
4401
4402 // TODO: refactor this so it's not copy/pasted 3 times
4403 tripoint tp = traj.front();
4404 if( !critter_at( tp ) ) {
4405 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4406 return;
4407 }
4408 std::size_t force_remaining = traj.size();
4409 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4410 if( stun > 0 ) {
4411 targ->add_effect( effect_stunned, 1_turns * stun );
4412 add_msg( _( "%s was stunned!" ), targ->name() );
4413 }
4414 for( size_t i = 1; i < traj.size(); i++ ) {
4415 if( m.impassable( traj[i].xy() ) || m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) {
4416 targ->setpos( traj[i - 1] );
4417 force_remaining = traj.size() - i;
4418 if( stun != 0 ) {
4419 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4420 add_msg( _( "%s was stunned!" ), targ->name() );
4421 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4422 targ->apply_damage( nullptr, bodypart_id( "torso" ), dam_mult * force_remaining );
4423 targ->check_dead_state();
4424 }
4425 m.bash( traj[i], 2 * dam_mult * force_remaining );
4426 break;
4427 } else if( critter_at( traj[i] ) ) {
4428 targ->setpos( traj[i - 1] );
4429 force_remaining = traj.size() - i;
4430 if( stun != 0 ) {
4431 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4432 add_msg( _( "%s was stunned!" ), targ->name() );
4433 }
4434 traj.erase( traj.begin(), traj.begin() + i );
4435 if( critter_at<monster>( traj.front() ) ) {
4436 add_msg( _( "%s collided with something else and sent it flying!" ),
4437 targ->name() );
4438 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4439 if( guy->male ) {
4440 add_msg( _( "%s collided with someone else and sent him flying!" ),
4441 targ->name() );
4442 } else {
4443 add_msg( _( "%s collided with someone else and sent her flying!" ),
4444 targ->name() );
4445 }
4446 } else if( u.pos() == traj.front() ) {
4447 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4448 }
4449 knockback( traj, stun, dam_mult );
4450 break;
4451 }
4452 targ->setpos( traj[i] );
4453 if( m.has_flag( "LIQUID", targ->pos() ) && !targ->can_drown() && !targ->is_dead() ) {
4454 targ->die( nullptr );
4455 if( u.sees( *targ ) ) {
4456 add_msg( _( "The %s drowns!" ), targ->name() );
4457 }
4458 }
4459 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4460 !targ->is_dead() ) {
4461 targ->die( nullptr );
4462 if( u.sees( *targ ) ) {
4463 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4464 }
4465 }
4466 tp = traj[i];
4467 }
4468 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4469 if( stun > 0 ) {
4470 targ->add_effect( effect_stunned, 1_turns * stun );
4471 add_msg( _( "%s was stunned!" ), targ->name );
4472 }
4473 for( size_t i = 1; i < traj.size(); i++ ) {
4474 if( m.impassable( traj[i].xy() ) ||
4475 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4476 targ->setpos( traj[i - 1] );
4477 force_remaining = traj.size() - i;
4478 if( stun != 0 ) {
4479 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4480 if( targ->has_effect( effect_stunned ) ) {
4481 add_msg( _( "%s was stunned!" ), targ->name );
4482 }
4483
4484 std::array<bodypart_id, 8> bps = {{
4485 bodypart_id( "head" ),
4486 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4487 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4488 bodypart_id( "torso" ),
4489 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4490 }
4491 };
4492 for( const bodypart_id &bp : bps ) {
4493 if( one_in( 2 ) ) {
4494 targ->deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4495 }
4496 }
4497 targ->check_dead_state();
4498 }
4499 m.bash( traj[i], 2 * dam_mult * force_remaining );
4500 break;
4501 } else if( critter_at( traj[i] ) ) {
4502 targ->setpos( traj[i - 1] );
4503 force_remaining = traj.size() - i;
4504 if( stun != 0 ) {
4505 add_msg( _( "%s was stunned!" ), targ->name );
4506 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4507 }
4508 traj.erase( traj.begin(), traj.begin() + i );
4509 const tripoint &traj_front = traj.front();
4510 if( critter_at<monster>( traj_front ) ) {
4511 add_msg( _( "%s collided with something else and sent it flying!" ),
4512 targ->name );
4513 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4514 if( guy->male ) {
4515 add_msg( _( "%s collided with someone else and sent him flying!" ),
4516 targ->name );
4517 } else {
4518 add_msg( _( "%s collided with someone else and sent her flying!" ),
4519 targ->name );
4520 }
4521 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4523 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4524 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4525 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4526 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4527 }
4528 knockback( traj, stun, dam_mult );
4529 break;
4530 }
4531 targ->setpos( traj[i] );
4532 tp = traj[i];
4533 }
4534 } else if( u.pos() == tp ) {
4535 if( stun > 0 ) {
4536 u.add_effect( effect_stunned, 1_turns * stun );
4537 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4538 "You were stunned for %d turns!",
4539 stun ),
4540 stun );
4541 }
4542 for( size_t i = 1; i < traj.size(); i++ ) {
4543 if( m.impassable( traj[i] ) ||
4544 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4545 u.setpos( traj[i - 1] );
4546 force_remaining = traj.size() - i;
4547 if( stun != 0 ) {
4548 if( u.has_effect( effect_stunned ) ) {
4549 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4550 "You were stunned AGAIN for %d turns!",
4551 force_remaining ),
4552 force_remaining );
4553 } else {
4554 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4555 "You were stunned for %d turns!",
4556 force_remaining ),
4557 force_remaining );
4558 }
4559 u.add_effect( effect_stunned, 1_turns * force_remaining );
4560 std::array<bodypart_id, 8> bps = {{
4561 bodypart_id( "head" ),
4562 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4563 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4564 bodypart_id( "torso" ),
4565 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4566 }
4567 };
4568 for( const bodypart_id &bp : bps ) {
4569 if( one_in( 2 ) ) {
4570 u.deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4571 }
4572 }
4574 }
4575 m.bash( traj[i], 2 * dam_mult * force_remaining );
4576 break;
4577 } else if( critter_at( traj[i] ) ) {
4578 u.setpos( traj[i - 1] );
4579 force_remaining = traj.size() - i;
4580 if( stun != 0 ) {
4581 if( u.has_effect( effect_stunned ) ) {
4582 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4583 "You were stunned AGAIN for %d turns!",
4584 force_remaining ),
4585 force_remaining );
4586 } else {
4587 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4588 "You were stunned for %d turns!",
4589 force_remaining ),
4590 force_remaining );
4591 }
4592 u.add_effect( effect_stunned, 1_turns * force_remaining );
4593 }
4594 traj.erase( traj.begin(), traj.begin() + i );
4595 if( critter_at<monster>( traj.front() ) ) {
4596 add_msg( _( "You collided with something and sent it flying!" ) );
4597 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4598 if( guy->male ) {
4599 add_msg( _( "You collided with someone and sent him flying!" ) );
4600 } else {
4601 add_msg( _( "You collided with someone and sent her flying!" ) );
4602 }
4603 }
4604 knockback( traj, stun, dam_mult );
4605 break;
4606 }
4607 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4608 avatar_action::swim( m, u, u.pos() );
4609 } else {
4610 u.setpos( traj[i] );
4611 }
4612
4613 tp = traj[i];
4614 }
4615 }
4616}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8935
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8459
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:980
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, map::obstructed_by_vehicle_rotation(), one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3695 of file game.cpp.

3696{
3697 const float light = natural_light_level( zlev );
3698 return LIGHT_RANGE( light );
3699}
float natural_light_level(int zlev) const
Definition: game.cpp:3635
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 2902 of file game.cpp.

2903{
2904 std::vector<std::string> saves;
2905 for( auto &worldsave : world_generator->active_world->world_saves ) {
2906 saves.push_back( worldsave.player_name() );
2907 }
2908 return saves;
2909}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7349 of file game.cpp.

7350{
7351 std::vector<map_item_stack> ground_items = item_list;
7352 int iInfoHeight = 0;
7353 int iMaxRows = 0;
7354 int width = 0;
7355 int max_name_width = 0;
7356
7357 //find max length of item name and resize window width
7358 for( const map_item_stack &cur_item : ground_items ) {
7359 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7360 if( item_len > max_name_width ) {
7361 max_name_width = item_len;
7362 }
7363 }
7364
7365 tripoint active_pos;
7366 map_item_stack *activeItem = nullptr;
7367
7368 catacurses::window w_items;
7369 catacurses::window w_items_border;
7370 catacurses::window w_item_info;
7371
7372 ui_adaptor ui;
7373 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7374 iInfoHeight = std::min( 25, TERMY / 2 );
7375 iMaxRows = TERMY - iInfoHeight - 2;
7376
7377 width = clamp( max_name_width, 45, TERMX / 3 );
7378
7379 const int offsetX = TERMX - width;
7380
7381 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7382 width - 2, point( offsetX + 1, 1 ) );
7383 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7384 width, point( offsetX, 0 ) );
7385 w_item_info = catacurses::newwin( iInfoHeight, width,
7386 point( offsetX, TERMY - iInfoHeight ) );
7387
7388 if( activeItem ) {
7389 centerlistview( active_pos, width );
7390 }
7391
7392 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7393 } );
7394 ui.mark_resize();
7395
7396 // use previously selected sorting method
7397 bool sort_radius = uistate.list_item_sort != 2;
7398 bool addcategory = !sort_radius;
7399
7400 // reload filter/priority settings on the first invocation, if they were active
7401 if( !uistate.list_item_init ) {
7404 }
7407 }
7410 }
7411 uistate.list_item_init = true;
7412 }
7413
7414 //this stores only those items that match our filter
7415 std::vector<map_item_stack> filtered_items =
7416 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7417 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7418 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7419 int iItemNum = ground_items.size();
7420
7421 const tripoint stored_view_offset = u.view_offset;
7422
7424
7425 int iActive = 0; // Item index that we're looking at
7426 bool refilter = true;
7427 int page_num = 0;
7428 int iCatSortNum = 0;
7429 int iScrollPos = 0;
7430 std::map<int, std::string> mSortCategory;
7431
7432 std::string action;
7433 input_context ctxt( "LIST_ITEMS" );
7434 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7435 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7436 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7437 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7438 ctxt.register_action( "PAGE_DOWN" );
7439 ctxt.register_action( "PAGE_UP" );
7440 ctxt.register_action( "NEXT_TAB" );
7441 ctxt.register_action( "PREV_TAB" );
7442 ctxt.register_action( "HELP_KEYBINDINGS" );
7443 ctxt.register_action( "QUIT" );
7444 ctxt.register_action( "FILTER" );
7445 ctxt.register_action( "RESET_FILTER" );
7446 ctxt.register_action( "EXAMINE" );
7447 ctxt.register_action( "COMPARE" );
7448 ctxt.register_action( "PRIORITY_INCREASE" );
7449 ctxt.register_action( "PRIORITY_DECREASE" );
7450 ctxt.register_action( "SORT" );
7451 ctxt.register_action( "TRAVEL_TO" );
7452
7454
7455 ui.on_redraw( [&]( const ui_adaptor & ) {
7456 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7457
7458 if( ground_items.empty() ) {
7459 wnoutrefresh( w_items_border );
7460 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7461 } else {
7462 int iStartPos = 0;
7463 werase( w_items );
7464 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7465 int iNum = 0;
7466 bool high = false;
7467 bool low = false;
7468 int index = 0;
7469 int iCatSortOffset = 0;
7470
7471 for( int i = 0; i < iStartPos; i++ ) {
7472 if( !mSortCategory[i].empty() ) {
7473 iNum++;
7474 }
7475 }
7476 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7477 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7478 high = true;
7479 low = false;
7480 } else if( index >= lowPStart + iCatSortOffset ) {
7481 high = false;
7482 low = true;
7483 } else {
7484 high = false;
7485 low = false;
7486 }
7487
7488 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7489 int iThisPage = 0;
7490 if( !mSortCategory[iNum].empty() ) {
7491 iCatSortOffset++;
7492 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7493 } else {
7494 if( iNum == iActive ) {
7495 iThisPage = page_num;
7496 }
7497 std::string sText;
7498 if( iter->vIG.size() > 1 ) {
7499 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7500 }
7501 sText += iter->example->tname();
7502 if( iter->vIG[iThisPage].count > 1 ) {
7503 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7504 }
7505
7506 nc_color col = c_light_green;
7507 if( iNum != iActive ) {
7508 if( high ) {
7509 col = c_yellow;
7510 } else if( low ) {
7511 col = c_red;
7512 } else {
7513 col = iter->example->color_in_inventory();
7514 }
7515 }
7516 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7517 const int numw = iItemNum > 9 ? 2 : 1;
7518 const int x = iter->vIG[iThisPage].pos.x;
7519 const int y = iter->vIG[iThisPage].pos.y;
7520 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7521 iNum == iActive ? c_light_green : c_light_gray,
7522 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7524 ++iter;
7525 }
7526 } else {
7527 ++iter;
7528 }
7529 iNum++;
7530 }
7531 iNum = 0;
7532 for( int i = 0; i < iActive; i++ ) {
7533 if( !mSortCategory[i].empty() ) {
7534 iNum++;
7535 }
7536 }
7537 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7538 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7539 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7540 werase( w_item_info );
7541
7542 if( iItemNum > 0 && activeItem ) {
7543 std::vector<iteminfo> vThisItem;
7544 std::vector<iteminfo> vDummy;
7545 activeItem->example->info( true, vThisItem );
7546
7547 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7548 dummy.without_getch = true;
7549 dummy.without_border = true;
7550
7551 draw_item_info( w_item_info, dummy );
7552 }
7553 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7554 wnoutrefresh( w_items_border );
7555 }
7556
7557 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7558 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7559
7560 if( iItemNum > 0 && activeItem ) {
7561 // print info window title: < item name >
7562 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7563 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7564 activeItem->example->display_name() );
7565 wprintw( w_item_info, " >" );
7566 }
7567
7568 wnoutrefresh( w_items );
7569 wnoutrefresh( w_item_info );
7570
7571 if( filter_type ) {
7572 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7573 }
7574 } );
7575
7576 cata::optional<tripoint> trail_start;
7577 cata::optional<tripoint> trail_end;
7578 bool trail_end_x = false;
7579 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7580 trail_end_x );
7581 add_draw_callback( trail_cb );
7582
7583 do {
7584 if( action == "COMPARE" && activeItem ) {
7585 game_menus::inv::compare( u, active_pos );
7586 } else if( action == "FILTER" ) {
7587 filter_type = item_filter_type::FILTER;
7588 ui.invalidate_ui();
7590 .title( _( "Filter:" ) )
7591 .width( 55 )
7592 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7593 .identifier( "item_filter" )
7594 .max_length( 256 )
7595 .edit( sFilter );
7596 refilter = true;
7597 addcategory = !sort_radius;
7599 filter_type = cata::nullopt;
7600 } else if( action == "RESET_FILTER" ) {
7601 sFilter.clear();
7602 filtered_items = ground_items;
7603 refilter = true;
7605 addcategory = !sort_radius;
7606 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7607 std::vector<iteminfo> vThisItem;
7608 std::vector<iteminfo> vDummy;
7609 activeItem->example->info( true, vThisItem );
7610
7611 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7612 vDummy );
7613 info_data.handle_scrolling = true;
7614
7616 return catacurses::newwin( TERMY, width - 5, point_zero );
7617 }, info_data );
7618 } else if( action == "PRIORITY_INCREASE" ) {
7619 filter_type = item_filter_type::HIGH_PRIORITY;
7620 ui.invalidate_ui();
7622 .title( _( "High Priority:" ) )
7623 .width( 55 )
7625 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7626 .identifier( "list_item_priority" )
7627 .max_length( 256 )
7628 .query_string();
7629 refilter = true;
7630 addcategory = !sort_radius;
7632 filter_type = cata::nullopt;
7633 } else if( action == "PRIORITY_DECREASE" ) {
7634 filter_type = item_filter_type::LOW_PRIORITY;
7635 ui.invalidate_ui();
7637 .title( _( "Low Priority:" ) )
7638 .width( 55 )
7640 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7641 .identifier( "list_item_downvote" )
7642 .max_length( 256 )
7643 .query_string();
7644 refilter = true;
7645 addcategory = !sort_radius;
7647 filter_type = cata::nullopt;
7648 } else if( action == "SORT" ) {
7649 if( sort_radius ) {
7650 sort_radius = false;
7651 addcategory = true;
7652 uistate.list_item_sort = 2; // list is sorted by category
7653 } else {
7654 sort_radius = true;
7655 uistate.list_item_sort = 1; // list is sorted by distance
7656 }
7657 highPEnd = -1;
7658 lowPStart = -1;
7659 iCatSortNum = 0;
7660
7661 mSortCategory.clear();
7662 refilter = true;
7663 } else if( action == "TRAVEL_TO" && activeItem ) {
7664 if( !u.sees( u.pos() + active_pos ) ) {
7665 add_msg( _( "You can't see that destination." ) );
7666 }
7667 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7668 u.get_path_avoid() );
7669 if( route.size() > 1 ) {
7670 route.pop_back();
7671 u.set_destination( route );
7672 break;
7673 } else {
7674 add_msg( m_info, _( "You can't travel there." ) );
7675 }
7676 }
7677 if( uistate.list_item_sort == 1 ) {
7678 ground_items = item_list;
7679 } else if( uistate.list_item_sort == 2 ) {
7680 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7681 }
7682
7683 if( refilter ) {
7684 refilter = false;
7685 filtered_items = filter_item_stacks( ground_items, sFilter );
7686 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7687 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7688 iActive = 0;
7689 page_num = 0;
7690 iItemNum = filtered_items.size();
7691 }
7692
7693 if( addcategory ) {
7694 addcategory = false;
7695 iCatSortNum = 0;
7696 mSortCategory.clear();
7697 if( highPEnd > 0 ) {
7698 mSortCategory[0] = _( "HIGH PRIORITY" );
7699 iCatSortNum++;
7700 }
7701 std::string last_cat_name;
7702 for( int i = std::max( 0, highPEnd );
7703 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7704 const std::string &cat_name = filtered_items[i].example->get_category().name();
7705 if( cat_name != last_cat_name ) {
7706 mSortCategory[i + iCatSortNum++] = cat_name;
7707 last_cat_name = cat_name;
7708 }
7709 }
7710 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7711 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7712 }
7713 if( !mSortCategory[0].empty() ) {
7714 iActive++;
7715 }
7716 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7717 }
7718
7719 if( action == "UP" ) {
7720 do {
7721 iActive--;
7722
7723 } while( !mSortCategory[iActive].empty() );
7724 iScrollPos = 0;
7725 page_num = 0;
7726 if( iActive < 0 ) {
7727 iActive = iItemNum - 1;
7728 }
7729 } else if( action == "DOWN" ) {
7730 do {
7731 iActive++;
7732
7733 } while( !mSortCategory[iActive].empty() );
7734 iScrollPos = 0;
7735 page_num = 0;
7736 if( iActive >= iItemNum ) {
7737 iActive = mSortCategory[0].empty() ? 0 : 1;
7738 }
7739 } else if( action == "RIGHT" ) {
7740 if( !filtered_items.empty() && activeItem ) {
7741 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7742 page_num = activeItem->vIG.size() - 1;
7743 }
7744 }
7745 } else if( action == "LEFT" ) {
7746 page_num = std::max( 0, page_num - 1 );
7747 } else if( action == "PAGE_UP" ) {
7748 iScrollPos--;
7749 } else if( action == "PAGE_DOWN" ) {
7750 iScrollPos++;
7751 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7752 u.view_offset = stored_view_offset;
7754 }
7755
7756 active_pos = tripoint_zero;
7757 activeItem = nullptr;
7758
7759 if( mSortCategory[iActive].empty() ) {
7760 auto iter = filtered_items.begin();
7761 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7762 if( mSortCategory[iNum].empty() ) {
7763 ++iter;
7764 }
7765 }
7766 if( iter != filtered_items.end() ) {
7767 active_pos = iter->vIG[page_num].pos;
7768 activeItem = &( *iter );
7769 }
7770 }
7771
7772 if( activeItem ) {
7773 centerlistview( active_pos, width );
7774 trail_start = u.pos();
7775 trail_end = u.pos() + active_pos;
7776 // Actually accessed from the terrain overlay callback `trail_cb` in the
7777 // call to `ui_manager::redraw`.
7778 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7779 trail_end_x = true;
7780 } else {
7781 u.view_offset = stored_view_offset;
7782 trail_start = trail_end = cata::nullopt;
7783 }
7785
7787
7788 action = ctxt.handle_input();
7789 } while( action != "QUIT" );
7790
7791 u.view_offset = stored_view_offset;
7792 return game::vmenu_ret::QUIT;
7793}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1052
std::string list_item_downvote
Definition: game.h:1053
std::string sFilter
Definition: game.h:1051
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7236
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1104
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4042
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9699
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4465
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3215
uistatedata uistate
Definition: game.cpp:275
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7081
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7304 of file game.cpp.

7305{
7306 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7307 // whole reality bubble
7308 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7309
7310 if( mons.empty() && items.empty() ) {
7311 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7312 return;
7313 }
7314
7315 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7316 const auto att_lhs = lhs->attitude_to( u );
7317 const auto att_rhs = rhs->attitude_to( u );
7318
7319 return att_lhs < att_rhs || ( att_lhs == att_rhs
7320 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7321 } );
7322
7323 // If the current list is empty, switch to the non-empty list
7325 if( items.empty() ) {
7326 uistate.vmenu_show_items = false;
7327 }
7328 } else if( mons.empty() ) {
7330 }
7331
7334 while( true ) {
7335 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7338 } else {
7339 break;
7340 }
7341 }
7342
7343 if( ret == game::vmenu_ret::FIRE ) {
7345 }
7347}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7795
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7349
vmenu_ret
Definition: game.h:790
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:7004
void temp_exit_fullscreen()
Definition: game.cpp:546
void reenter_fullscreen()
Definition: game.cpp:556
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:844
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:211
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:190
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:180
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:175
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:185
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
#define BORDER_COLOR
Definition: output.h:135
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7795 of file game.cpp.

7796{
7797 const int iInfoHeight = 15;
7798 const int width = 45;
7799 int offsetX = 0;
7800 int iMaxRows = 0;
7801
7802 catacurses::window w_monsters;
7803 catacurses::window w_monsters_border;
7804 catacurses::window w_monster_info;
7805 catacurses::window w_monster_info_border;
7806
7807 Creature *cCurMon = nullptr;
7808 tripoint iActivePos;
7809
7810 bool hide_ui = false;
7811
7812 ui_adaptor ui;
7813 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7814 if( hide_ui ) {
7815 ui.position( point_zero, point_zero );
7816 } else {
7817 offsetX = TERMX - width;
7818 iMaxRows = TERMY - iInfoHeight - 1;
7819
7820 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
7821 1 ) );
7822 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
7823 0 ) );
7824 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
7825 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
7826 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
7827 TERMY - iInfoHeight ) );
7828
7829 if( cCurMon ) {
7830 centerlistview( iActivePos, width );
7831 }
7832
7833 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7834 }
7835 } );
7836 ui.mark_resize();
7837
7838 const int max_gun_range = u.weapon.gun_range( &u );
7839
7840 const tripoint stored_view_offset = u.view_offset;
7842
7843 int iActive = 0; // monster index that we're looking at
7844
7845 std::string action;
7846 input_context ctxt( "LIST_MONSTERS" );
7847 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7848 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7849 ctxt.register_action( "NEXT_TAB" );
7850 ctxt.register_action( "PREV_TAB" );
7851 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
7852 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
7853 ctxt.register_action( "QUIT" );
7854 if( bVMonsterLookFire ) {
7855 ctxt.register_action( "look" );
7856 ctxt.register_action( "fire" );
7857 }
7858 ctxt.register_action( "HELP_KEYBINDINGS" );
7859
7860 // first integer is the row the attitude category string is printed in the menu
7861 std::map<int, Creature::Attitude> mSortCategory;
7862
7863 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
7864 const auto attitude = monster_list[i]->attitude_to( u );
7865 if( attitude != last_attitude ) {
7866 mSortCategory[i + mSortCategory.size()] = attitude;
7867 last_attitude = attitude;
7868 }
7869 }
7870
7871 ui.on_redraw( [&]( const ui_adaptor & ) {
7872 if( !hide_ui ) {
7873 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
7874 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7875 true );
7876
7877 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
7878 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
7879
7880 if( monster_list.empty() ) {
7881 werase( w_monsters );
7882 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
7883 _( "You don't see any monsters around you!" ) );
7884 } else {
7885 werase( w_monsters );
7886
7887 const int iNumMonster = monster_list.size();
7888 const int iMenuSize = monster_list.size() + mSortCategory.size();
7889
7890 const int numw = iNumMonster > 999 ? 4 :
7891 iNumMonster > 99 ? 3 :
7892 iNumMonster > 9 ? 2 : 1;
7893
7894 // given the currently selected monster iActive. get the selected row
7895 int iSelPos = iActive;
7896 for( auto &ia : mSortCategory ) {
7897 int index = ia.first;
7898 if( index <= iSelPos ) {
7899 ++iSelPos;
7900 } else {
7901 break;
7902 }
7903 }
7904 int iStartPos = 0;
7905 // use selected row get the start row
7906 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
7907
7908 // get first visible monster and category
7909 int iCurMon = iStartPos;
7910 auto CatSortIter = mSortCategory.cbegin();
7911 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
7912 ++CatSortIter;
7913 --iCurMon;
7914 }
7915
7916 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
7917 for( int y = 0; y < endY; ++y ) {
7918 if( CatSortIter != mSortCategory.cend() ) {
7919 const int iCurPos = iStartPos + y;
7920 const int iCatPos = CatSortIter->first;
7921 if( iCurPos == iCatPos ) {
7922 const std::string cat_name = Creature::get_attitude_ui_data(
7923 CatSortIter->second ).first.translated();
7924 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
7925 ++CatSortIter;
7926 continue;
7927 }
7928 }
7929 // select current monster
7930 const auto critter = monster_list[iCurMon];
7931 const bool selected = iCurMon == iActive;
7932 ++iCurMon;
7933 if( critter->sees( g->u ) ) {
7934 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
7935 }
7936 bool is_npc = false;
7937 const monster *m = dynamic_cast<monster *>( critter );
7938 const npc *p = dynamic_cast<npc *>( critter );
7939 nc_color name_color = critter->basic_symbol_color();
7940
7941 if( selected ) {
7942 name_color = hilite( name_color );
7943 }
7944
7945 if( m != nullptr ) {
7946 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
7947 } else {
7948 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
7949 is_npc = true;
7950 }
7951
7952 if( selected && !get_safemode().empty() ) {
7953 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
7954
7955 std::string sSafemode;
7956 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
7957 sSafemode = _( "<R>emove from safemode Blacklist" );
7958 } else {
7959 sSafemode = _( "<A>dd to safemode Blacklist" );
7960 }
7961
7962 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
7963 c_white, c_light_green, sSafemode );
7964 }
7965
7967 std::string sText;
7968
7969 if( m != nullptr ) {
7970 m->get_HP_Bar( color, sText );
7971 } else {
7972 std::tie( sText, color ) =
7973 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
7974 }
7975 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
7976
7977 if( m != nullptr ) {
7978 const auto att = m->get_attitude();
7979 sText = att.first;
7980 color = att.second;
7981 } else if( p != nullptr ) {
7982 sText = npc_attitude_name( p->get_attitude() );
7983 color = p->symbol_color();
7984 }
7985 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
7986
7987 const int mon_dist = rl_dist( u.pos(), critter->pos() );
7988 const int numd = mon_dist > 999 ? 4 :
7989 mon_dist > 99 ? 3 :
7990 mon_dist > 9 ? 2 : 1;
7991
7992 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
7993 selected ? c_light_green : c_light_gray,
7994 "%*d %s",
7995 numd, mon_dist,
7996 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
7997 }
7998
7999 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
8000 iActive + 1 );
8001 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
8002
8003 werase( w_monster_info );
8004 if( cCurMon ) {
8005 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
8006 }
8007
8008 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8009 true );
8010
8011 if( bVMonsterLookFire ) {
8012 mvwprintw( w_monster_info_border, point_east, "< " );
8013 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
8014 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
8015
8016 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8017 wprintw( w_monster_info_border, " " );
8018 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
8019 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
8020 }
8021 wprintw( w_monster_info_border, " >" );
8022 }
8023
8024 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
8025 point_south );
8026 }
8027
8028 wnoutrefresh( w_monsters_border );
8029 wnoutrefresh( w_monster_info_border );
8030 wnoutrefresh( w_monsters );
8031 wnoutrefresh( w_monster_info );
8032 }
8033 } );
8034
8035 cata::optional<tripoint> trail_start;
8036 cata::optional<tripoint> trail_end;
8037 bool trail_end_x = false;
8038 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
8039 trail_end_x );
8040 add_draw_callback( trail_cb );
8041
8042 do {
8043 if( action == "UP" ) {
8044 iActive--;
8045 if( iActive < 0 ) {
8046 if( monster_list.empty() ) {
8047 iActive = 0;
8048 } else {
8049 iActive = static_cast<int>( monster_list.size() ) - 1;
8050 }
8051 }
8052 } else if( action == "DOWN" ) {
8053 iActive++;
8054 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8055 iActive = 0;
8056 }
8057 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8058 u.view_offset = stored_view_offset;
8060 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8061 const auto m = dynamic_cast<monster *>( cCurMon );
8062 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8063
8064 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8066 }
8067 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8068 if( !get_safemode().empty() ) {
8069 const auto m = dynamic_cast<monster *>( cCurMon );
8070 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8071
8072 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8074 }
8075 } else if( action == "look" ) {
8076 hide_ui = true;
8077 ui.mark_resize();
8078 look_around();
8079 hide_ui = false;
8080 ui.mark_resize();
8081 } else if( action == "fire" ) {
8082 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8083 u.last_target = shared_from( *cCurMon );
8085 u.view_offset = stored_view_offset;
8086 return game::vmenu_ret::FIRE;
8087 }
8088 }
8089
8090 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8091 cCurMon = monster_list[iActive];
8092 iActivePos = cCurMon->pos() - u.pos();
8093 centerlistview( iActivePos, width );
8094 trail_start = u.pos();
8095 trail_end = cCurMon->pos();
8096 // Actually accessed from the terrain overlay callback `trail_cb` in the
8097 // call to `ui_manager::redraw`.
8098 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8099 trail_end_x = false;
8100 } else {
8101 cCurMon = nullptr;
8102 iActivePos = tripoint_zero;
8103 u.view_offset = stored_view_offset;
8104 trail_start = trail_end = cata::nullopt;
8105 }
8107
8109
8110 action = ctxt.handle_input();
8111 } while( action != "QUIT" );
8112
8113 u.view_offset = stored_view_offset;
8114
8115 return game::vmenu_ret::QUIT;
8116}
double recoil
Definition: character.h:561
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6109
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1860
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4698
bool bVMonsterLookFire
Definition: game.h:1056
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7222
npc_attitude get_attitude() const
Definition: npc.cpp:3139
weak_ptr_fast< Creature > last_target
Definition: player.h:595
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2545
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2623 of file game.cpp.

2624{
2627 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2630
2631 using namespace std::placeholders;
2632
2633 const std::string worldpath = get_world_base_save_path() + "/";
2634 const std::string playerpath = worldpath + name.base_path();
2635
2636 // Now load up the master game data; factions (and more?)
2637 load_master();
2638 u = avatar();
2639 u.name = name.player_name();
2640 // This should be initialized more globally (in player/Character constructor)
2642 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2643 return false;
2644 }
2645
2647
2649
2650 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2651 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2652
2653#if defined(__ANDROID__)
2654 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2655 std::bind( &game::load_shortcuts, this, _1 ) );
2656#endif
2657
2658 // Now that the player's worn items are updated, their sight limits need to be
2659 // recalculated. (This would be cleaner if u.worn were private.)
2661
2662 if( !gamemode ) {
2663 gamemode = std::make_unique<special_game>();
2664 }
2665
2666 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2667 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2668
2669 init_autosave();
2670 get_auto_pickup().load_character(); // Load character auto pickup rules
2671 get_auto_notes_settings().load(); // Load character auto notes settings
2672 get_safemode().load_character(); // Load character safemode rules
2673 zone_manager::get_manager().load_zones(); // Load character world zones
2674 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2675 JsonIn jsin( stream );
2676 uistate.deserialize( jsin );
2677 } );
2678 reload_npcs();
2683 update_map( u );
2684 for( auto &e : u.inv_dump() ) {
2685 e->set_owner( g->u );
2686 }
2687 // legacy, needs to be here as we access the map.
2688 if( !u.getID().is_valid() ) {
2689 // player does not have a real id, so assign a new one,
2690 u.setID( assign_npc_id() );
2691 // The vehicle stores the IDs of the boarded players, so update it, too.
2692 if( u.in_vehicle ) {
2694 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2695 vp->part().passenger_id = u.getID();
2696 }
2697 }
2698 }
2699
2700 // populate calendar caches now, after active world is set, but before we do
2701 // anything else, to ensure they pick up the correct value from the save's
2702 // worldoptions
2703 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2704 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2705
2706 u.reset();
2707
2708 return true;
2709}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:466
std::vector< item * > inv_dump()
Definition: character.cpp:8959
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1703
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3622
Definition: json.h:177
Definition: avatar.h:54
void load_map_memory()
Definition: avatar.cpp:134
bool is_valid() const
Definition: character_id.h:19
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1988
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:968
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2046
void load_master()
Definition: game.cpp:2592
void validate_mounted_npcs()
Definition: game.cpp:2003
character_id assign_npc_id()
Definition: game.cpp:3709
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11333
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2022
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:276
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2599 of file game.cpp.

2600{
2601 world_generator->init();
2602 const WORLDPTR wptr = world_generator->get_world( world );
2603 if( !wptr ) {
2604 return false;
2605 }
2606 if( wptr->world_saves.empty() ) {
2607 debugmsg( "world '%s' contains no saves", world );
2608 return false;
2609 }
2610
2611 try {
2612 world_generator->set_active_world( wptr );
2613 g->setup();
2614 g->load( wptr->world_saves.front() );
2615 } catch( const std::exception &err ) {
2616 debugmsg( "cannot load world '%s': %s", world, err.what() );
2617 return false;
2618 }
2619
2620 return true;
2621}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 441 of file game.cpp.

442{
443 // core data can be loaded only once and must be first
444 // anyway.
446
448}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:528
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 450 of file game.cpp.

451{
453}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:458

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Definition at line 642 of file game.cpp.

643{
644 // TODO: fix point types
645 load_map( tripoint_abs_sm( pos_sm ) );
646}
void load_map(const tripoint &pos_sm)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:642
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm)

Definition at line 648 of file game.cpp.

649{
650 m.load( pos_sm, true );
651 grid_tracker_ptr->load( m );
652}
void load(const tripoint &w, bool update_vehicles)
Load submaps into grid.
Definition: map.cpp:6601

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2592 of file game.cpp.

2593{
2594 using namespace std::placeholders;
2595 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2596 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2597}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1188
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 906 of file game.cpp.

907{
908 const int radius = HALF_MAPSIZE - 1;
909 // uses submap coordinates
910 std::vector<shared_ptr_fast<npc>> just_added;
911 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
912 const character_id &id = temp->getID();
913 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
914 [id]( const shared_ptr_fast<npc> &n ) {
915 return n->getID() == id;
916 } );
917 if( found != active_npc.end() ) {
918 continue;
919 }
920 if( temp->is_active() ) {
921 continue;
922 }
923 if( temp->has_companion_mission() ) {
924 continue;
925 }
926
927 const tripoint sm_loc = temp->global_sm_location();
928 // NPCs who are out of bounds before placement would be pushed into bounds
929 // This can cause NPCs to teleport around, so we don't want that
930 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
931 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
932 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
933 continue;
934 }
935
936 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
937 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
938 temp->place_on_map();
939 if( !m.inbounds( temp->pos() ) ) {
940 continue;
941 }
942 // In the rare case the npc was marked for death while
943 // it was on the overmap. Kill it.
944 if( temp->marked_for_death ) {
945 temp->die( nullptr );
946 } else {
947 active_npc.push_back( temp );
948 just_added.push_back( temp );
949 }
950 }
951
952 for( const auto &npc : just_added ) {
953 npc->on_load();
954 }
955
956 npcs_dirty = false;
957}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2658
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2747 of file game.cpp.

2748{
2749 ui.new_context( msg );
2750 std::vector<mod_id> missing;
2751 std::vector<mod_id> available;
2752
2753 for( const mod_id &e : packs ) {
2754 if( e.is_valid() ) {
2755 available.emplace_back( e );
2756 ui.add_entry( e->name() );
2757 } else {
2758 missing.push_back( e );
2759 }
2760 }
2761
2762 ui.show();
2763 for( const auto &e : available ) {
2764 const MOD_INFORMATION &mod = *e;
2765 load_data_from_dir( mod.path, mod.ident.str(), ui );
2766 ui.proceed();
2767 }
2768
2769 for( const auto &e : missing ) {
2770 debugmsg( "unknown content %s", e.c_str() );
2771 }
2772
2773 return missing.empty();
2774}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 327 of file game.cpp.

328{
329 // UI stuff, not mod-specific per definition
330 inp_mngr.init(); // Load input config JSON
331 // Init mappings for loading the json stuff
333 fullscreen = false;
334 was_fullscreen = false;
335 show_panel_adm = false;
337
338 // These functions do not load stuff from json.
339 // The content they load/initialize is hardcoded into the program.
340 // Therefore they can be loaded here.
341 // If this changes (if they load data from json), they have to
342 // be moved to game::load_mod or game::load_core_data
343
346}
bool was_fullscreen
Definition: game.h:1038
bool fullscreen
Definition: game.h:1037
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2310
void load_global()

References fullscreen, get_auto_pickup(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2711 of file game.cpp.

2712{
2713 auto &mods = world_generator->active_world->active_mod_order;
2714
2715 // remove any duplicates whilst preserving order (fixes #19385)
2716 std::set<mod_id> found;
2717 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2718 if( found.count( e ) ) {
2719 return true;
2720 } else {
2721 found.insert( e );
2722 return false;
2723 }
2724 } ), mods.end() );
2725
2726 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2727 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2728 return e->core;
2729} ) ) {
2730 mods.insert( mods.begin(), mod_id( "dda" ) );
2731 }
2732
2734 // this code does not care about mod dependencies,
2735 // it assumes that those dependencies are static and
2736 // are resolved during the creation of the world.
2737 // That means world->active_mod_order contains a list
2738 // of mods in the correct order.
2739 load_packs( _( "Loading files" ), mods, ui );
2740
2741 // Load additional mods from that world-specific folder
2742 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2743
2745}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( )

Definition at line 6654 of file game.cpp.

6655{
6657 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6658 false );
6659 return result.position;
6660}

References center, look_around(), Character::pos(), u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6662 of file game.cpp.

6665{
6666 bVMonsterLookFire = false;
6667 // TODO: Make this `true`
6668 const bool allow_zlev_move = m.has_zlevels() && get_option<bool>( "FOV_3D" );
6669
6671
6672 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6673 int &lx = lp.x;
6674 int &ly = lp.y;
6675 int &lz = lp.z;
6676
6677 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6678 bool fast_scroll = false;
6679
6680 std::unique_ptr<ui_adaptor> ui;
6681 catacurses::window w_info;
6682 if( show_window ) {
6683 ui = std::make_unique<ui_adaptor>();
6684 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6685 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6687
6688 // If particularly small, base height on panel width irrespective of other elements.
6689 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6690 if( height < panel_width / 2 ) {
6691 height = panel_width / 2;
6692 }
6693
6694 int la_y = 0;
6695 int la_x = TERMX - panel_width;
6696 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6697 if( position == "left" ) {
6698 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6700 } else {
6701 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6702 }
6703 }
6704 int la_h = height;
6705 int la_w = panel_width;
6706 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6707
6708 ui.position_from_window( w_info );
6709 } );
6710 ui->mark_resize();
6711 }
6712
6713 std::string action;
6714 input_context ctxt( "LOOK" );
6715 ctxt.set_iso( true );
6716 ctxt.register_directions();
6717 ctxt.register_action( "COORDINATE" );
6718 ctxt.register_action( "LEVEL_UP" );
6719 ctxt.register_action( "LEVEL_DOWN" );
6720 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6721 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6722 ctxt.register_action( "SELECT" );
6723 if( peeking ) {
6724 ctxt.register_action( "throw_blind" );
6725 }
6726 if( !select_zone ) {
6727 ctxt.register_action( "TRAVEL_TO" );
6728 ctxt.register_action( "LIST_ITEMS" );
6729 }
6730 ctxt.register_action( "MOUSE_MOVE" );
6731 ctxt.register_action( "CENTER" );
6732
6733 ctxt.register_action( "debug_scent" );
6734 ctxt.register_action( "debug_scent_type" );
6735 ctxt.register_action( "debug_temp" );
6736 ctxt.register_action( "debug_visibility" );
6737 ctxt.register_action( "debug_lighting" );
6738 ctxt.register_action( "debug_radiation" );
6739 ctxt.register_action( "debug_submap_grid" );
6740 ctxt.register_action( "debug_hour_timer" );
6741 ctxt.register_action( "CONFIRM" );
6742 ctxt.register_action( "QUIT" );
6743 ctxt.register_action( "HELP_KEYBINDINGS" );
6744 if( use_tiles ) {
6745 ctxt.register_action( "zoom_out" );
6746 ctxt.register_action( "zoom_in" );
6747 }
6748#if defined(TILES)
6749 ctxt.register_action( "toggle_pixel_minimap" );
6750#endif // TILES
6751
6752 const int old_levz = get_levz();
6753 const int min_levz = std::max( old_levz - fov_3d_z_range, -OVERMAP_DEPTH );
6754 const int max_levz = std::min( old_levz + fov_3d_z_range, OVERMAP_HEIGHT );
6755
6756 m.update_visibility_cache( old_levz );
6758
6759 bool blink = true;
6761
6762 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6763
6764 if( show_window && ui ) {
6765 ui->on_redraw( [&]( const ui_adaptor & ) {
6766 werase( w_info );
6767 draw_border( w_info );
6768
6769 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6770
6771 std::string extended_descr_text = string_format( _( "%s - %s" ),
6772 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6773 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6774 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6775 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6776 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6777#if defined(TILES)
6778 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6779 ctxt.get_desc( "toggle_pixel_minimap" ),
6780 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6781#endif // TILES
6782
6783 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6784 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6785 fast_scroll_text );
6786#if defined(TILES)
6787 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6788 pixel_minimap_text );
6789#endif // TILES
6790
6791 int first_line = 1;
6792 const int last_line = getmaxy( w_info ) - 3;
6793 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6794
6795 wnoutrefresh( w_info );
6796 } );
6797 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6798 draw_look_around_cursor( lp, cache );
6799 } );
6800 add_draw_callback( ter_indicator_cb );
6801 }
6802
6803 cata::optional<tripoint> zone_start;
6804 cata::optional<tripoint> zone_end;
6805 bool zone_blink = false;
6806 bool zone_cursor = true;
6807 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
6808 zone_cursor, is_moving_zone );
6809 add_draw_callback( zone_cb );
6810
6811 is_looking = true;
6812 const tripoint prev_offset = u.view_offset;
6813#if defined(TILES)
6814 const int prev_tileset_zoom = tileset_zoom;
6815 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
6816 get_zoom() != 4 ) {
6817 zoom_out();
6818 }
6820#endif
6821 do {
6822 u.view_offset = center - u.pos();
6823 if( select_zone ) {
6824 if( has_first_point ) {
6825 zone_start = start_point;
6826 zone_end = lp;
6827 } else {
6828 zone_start = lp;
6829 zone_end = cata::nullopt;
6830 }
6831 // Actually accessed from the terrain overlay callback `zone_cb` in the
6832 // call to `ui_manager::redraw`.
6833 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6834 zone_blink = blink;
6835 }
6836
6837 if( is_moving_zone ) {
6838 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
6839 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
6840 // Actually accessed from the terrain overlay callback `zone_cb` in the
6841 // call to `ui_manager::redraw`.
6842 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6843 zone_blink = blink;
6844 }
6847 if( ( select_zone && has_first_point ) || is_moving_zone ) {
6848 ctxt.set_timeout( BLINK_SPEED );
6849 }
6850
6851 //Wait for input
6852 // only specify a timeout here if "EDGE_SCROLL" is enabled
6853 // otherwise use the previously set timeout
6854 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
6855 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
6856 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
6857 if( edge_scrolling ) {
6858 action = ctxt.handle_input( scroll_timeout );
6859 } else {
6860 action = ctxt.handle_input();
6861 }
6862 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
6863 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
6864 blink = true; // Always draw blink symbols when moving cursor
6865 } else if( action == "TIMEOUT" ) {
6866 blink = !blink;
6867 }
6868 if( action == "LIST_ITEMS" ) {
6870 } else if( action == "TOGGLE_FAST_SCROLL" ) {
6871 fast_scroll = !fast_scroll;
6872 } else if( action == "toggle_pixel_minimap" ) {
6874
6875 if( show_window && ui ) {
6876 ui->mark_resize();
6877 }
6878 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
6879 if( !allow_zlev_move ) {
6880 continue;
6881 }
6882
6883 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
6884 lz = clamp( lz + dz, min_levz, max_levz );
6885 center.z = clamp( center.z + dz, min_levz, max_levz );
6886
6887 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
6888 u.view_offset.z = center.z - u.posz();
6890 } else if( action == "TRAVEL_TO" ) {
6891 if( !u.sees( lp ) ) {
6892 add_msg( _( "You can't see that destination." ) );
6893 continue;
6894 }
6895
6896 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
6897 if( route.size() > 1 ) {
6898 route.pop_back();
6899 u.set_destination( route );
6900 } else {
6901 add_msg( m_info, _( "You can't travel there." ) );
6902 continue;
6903 }
6904 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
6906 display_scent();
6907 }
6908 } else if( action == "debug_temp" ) {
6911 }
6912 } else if( action == "debug_lighting" ) {
6915 }
6916 } else if( action == "debug_transparency" ) {
6919 }
6920 } else if( action == "debug_radiation" ) {
6923 }
6924 } else if( action == "debug_submap_grid" ) {
6925 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
6926 } else if( action == "debug_hour_timer" ) {
6928 } else if( action == "EXTENDED_DESCRIPTION" ) {
6930 } else if( action == "CENTER" ) {
6931 center = u.pos();
6932 lp = u.pos();
6933 u.view_offset.z = 0;
6934 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
6935 // This block is structured this way so that edge scroll can work
6936 // whether the mouse is moving at the edge or simply stationary
6937 // at the edge. But even if edge scroll isn't in play, there's
6938 // other things for us to do here.
6939
6940 if( edge_scrolling ) {
6941 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
6942 } else if( action == "MOUSE_MOVE" ) {
6943 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
6944 if( mouse_pos ) {
6945 lx = mouse_pos->x;
6946 ly = mouse_pos->y;
6947 }
6948 }
6949 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
6950 if( fast_scroll ) {
6951 vec->x *= soffset;
6952 vec->y *= soffset;
6953 }
6954
6955 lx = lx + vec->x;
6956 ly = ly + vec->y;
6957 center.x = center.x + vec->x;
6958 center.y = center.y + vec->y;
6959 } else if( action == "throw_blind" ) {
6960 result.peek_action = PA_BLIND_THROW;
6961 } else if( action == "zoom_in" ) {
6962 center.x = lp.x;
6963 center.y = lp.y;
6964 zoom_in();
6966 } else if( action == "zoom_out" ) {
6967 center.x = lp.x;
6968 center.y = lp.y;
6969 zoom_out();
6971 }
6972 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
6973 action != "throw_blind" );
6974
6975 if( m.has_zlevels() && center.z != old_levz ) {
6976 m.invalidate_map_cache( old_levz );
6977 m.build_map_cache( old_levz );
6978 u.view_offset.z = 0;
6979 }
6980
6981 ctxt.reset_timeout();
6982 u.view_offset = prev_offset;
6983 zone_cb = nullptr;
6984 is_looking = false;
6985
6987 bVMonsterLookFire = true;
6988
6989 if( action == "CONFIRM" || action == "SELECT" ) {
6990 result.position = is_moving_zone ? zone_start : lp;
6991 }
6992
6993#if defined(TILES)
6994 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
6995 // Reset the tileset zoom to the previous value
6996 set_zoom( prev_tileset_zoom );
6998 }
6999#endif
7000
7001 return result;
7002}
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2173
void set_zoom(int level)
Definition: game.cpp:7159
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5767
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6641
int get_zoom() const
Definition: game.cpp:7171
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5637
void invalidate_map_cache(const int zlev)
Definition: map.h:475
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2278
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3168
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5760 of file game.cpp.

5761{
5762 editmap edit;
5763 return edit.edit();
5764}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3125 of file game.cpp.

3126{
3128 if( ui ) {
3129 ui->mark_resize();
3130 }
3131}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 2867 of file game.cpp.

2868{
2869 return *memorial_logger_ptr;
2870}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 3816 of file game.cpp.

3817{
3818 const monster_visible_info &mon_visible = u.get_mon_visible();
3819 const auto &unique_types = mon_visible.unique_types;
3820 const auto &unique_mons = mon_visible.unique_mons;
3821 const auto &dangerous = mon_visible.dangerous;
3822
3823 const int width = getmaxx( w ) - 2 * hor_padding;
3824 const int maxheight = getmaxy( w );
3825
3826 const int startrow = 0;
3827
3828 // Print the direction headings
3829 // Reminder:
3830 // 7 0 1 unique_types uses these indices;
3831 // 6 8 2 0-7 are provide by direction_from()
3832 // 5 4 3 8 is used for local monsters (for when we explain them below)
3833
3834 const std::array<std::string, 8> dir_labels = {{
3835 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
3836 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
3837 }
3838 };
3839 std::array<int, 8> widths;
3840 for( int i = 0; i < 8; i++ ) {
3841 widths[i] = utf8_width( dir_labels[i] );
3842 }
3843 std::array<int, 8> xcoords;
3844 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
3845 xcoords[0] = xcoords[4] = width / 3;
3846 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
3847 xcoords[5] = xcoords[6] = xcoords[7] = 0;
3848 //for the alignment of the 1,2,3 rows on the right edge
3849 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
3850 for( int i = 0; i < 8; i++ ) {
3851 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
3852 : ( dangerous[i] ? c_light_red : c_light_gray );
3853 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
3854 }
3855
3856 // Print the symbols of all monsters in all directions.
3857 for( int i = 0; i < 8; i++ ) {
3858 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
3859
3860 // The list of symbols needs a space on each end.
3861 int symroom = ( width / 3 ) - widths[i] - 2;
3862 const int typeshere_npc = unique_types[i].size();
3863 const int typeshere_mon = unique_mons[i].size();
3864 const int typeshere = typeshere_mon + typeshere_npc;
3865 for( int j = 0; j < typeshere && j < symroom; j++ ) {
3866 nc_color c;
3867 std::string sym;
3868 if( symroom < typeshere && j == symroom - 1 ) {
3869 // We've run out of room!
3870 c = c_white;
3871 sym = "+";
3872 } else if( j < typeshere_npc ) {
3873 switch( unique_types[i][j]->get_attitude() ) {
3874 case NPCATT_KILL:
3875 c = c_red;
3876 break;
3877 case NPCATT_FOLLOW:
3878 c = c_light_green;
3879 break;
3880 default:
3881 c = c_pink;
3882 break;
3883 }
3884 sym = "@";
3885 } else {
3886 const mtype &mt = *unique_mons[i][j - typeshere_npc].first;
3887 c = mt.color;
3888 sym = mt.sym;
3889 }
3890 mvwprintz( w, pr, c, sym );
3891
3892 pr.x++;
3893 }
3894 }
3895
3896 // Now we print their full names!
3897 struct nearest_loc_and_cnt {
3898 int nearest_loc;
3899 int cnt;
3900 };
3901 std::map<const mtype *, nearest_loc_and_cnt> all_mons;
3902 for( int loc = 0; loc < 9; loc++ ) {
3903 for( const std::pair<const mtype *, int> &mon : unique_mons[loc] ) {
3904 const auto mon_it = all_mons.find( mon.first );
3905 if( mon_it == all_mons.end() ) {
3906 all_mons.emplace( mon.first, nearest_loc_and_cnt{ loc, mon.second } );
3907 } else {
3908 // 8 being the nearest location (local monsters)
3909 mon_it->second.nearest_loc = std::max( mon_it->second.nearest_loc, loc );
3910 mon_it->second.cnt += mon.second;
3911 }
3912 }
3913 }
3914 std::vector<std::pair<const mtype *, int>> mons_at[9];
3915 for( const std::pair<const mtype *const, nearest_loc_and_cnt> &mon : all_mons ) {
3916 mons_at[mon.second.nearest_loc].emplace_back( mon.first, mon.second.cnt );
3917 }
3918
3919 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
3920 // is blank.
3921 point pr( hor_padding, 4 + startrow );
3922
3923 // Print monster names, starting with those at location 8 (nearby).
3924 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
3925 // Separate names by some number of spaces (more for local monsters).
3926 int namesep = ( j == 8 ? 2 : 1 );
3927 for( const std::pair<const mtype *, int> &mon : mons_at[j] ) {
3928 const mtype *const type = mon.first;
3929 const int count = mon.second;
3930 if( pr.y >= maxheight ) {
3931 // no space to print to anyway
3932 break;
3933 }
3934
3935 const mtype &mt = *type;
3936 std::string name = mt.nname( count );
3937 // Some languages don't have plural forms, but we want to always
3938 // omit 1.
3939 if( count != 1 ) {
3940 name = string_format( pgettext( "monster count and name", "%1$d %2$s" ),
3941 count, name );
3942 }
3943
3944 // Move to the next row if necessary. (The +2 is for the "Z ").
3945 if( pr.x + 2 + utf8_width( name ) >= width ) {
3946 pr.y++;
3947 pr.x = hor_padding;
3948 }
3949
3950 if( pr.y < maxheight ) { // Don't print if we've overflowed
3951 mvwprintz( w, pr, mt.color, mt.sym );
3952 pr.x += 2; // symbol and space
3953 nc_color danger = c_dark_gray;
3954 if( mt.difficulty >= 30 ) {
3955 danger = c_red;
3956 } else if( mt.difficulty >= 16 ) {
3957 danger = c_light_red;
3958 } else if( mt.difficulty >= 8 ) {
3959 danger = c_white;
3960 } else if( mt.agro > 0 ) {
3961 danger = c_light_gray;
3962 }
3963 mvwprintz( w, pr, danger, name );
3964 pr.x += utf8_width( name ) + namesep;
3965 }
3966 }
3967 }
3968}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< std::pair< const mtype *, int > > unique_mons[9]
Definition: avatar.h:47
bool dangerous[8]
Definition: avatar.h:50
std::vector< npc * > unique_types[9]
Definition: avatar.h:46
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:256
nc_color color
Definition: mtype.h:261
int difficulty
Definition: mtype.h:267
int agro
e.g.
Definition: mtype.h:272

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, detail::count(), monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, pgettext(), string_format(), mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 3970 of file game.cpp.

3971{
3972 int newseen = 0;
3973 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
3974 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
3975 safe_proxy_dist;
3976
3977 monster_visible_info &mon_visible = u.get_mon_visible();
3978 auto &new_seen_mon = mon_visible.new_seen_mon;
3979 auto &unique_types = mon_visible.unique_types;
3980 auto &unique_mons = mon_visible.unique_mons;
3981 auto &dangerous = mon_visible.dangerous;
3982
3983 // 7 0 1 unique_types uses these indices;
3984 // 6 8 2 0-7 are provide by direction_from()
3985 // 5 4 3 8 is used for local monsters (for when we explain them below)
3986 for( auto &t : unique_types ) {
3987 t.clear();
3988 }
3989 for( auto &m : unique_mons ) {
3990 m.clear();
3991 }
3992 std::fill( dangerous, dangerous + 8, false );
3993
3994 const tripoint view = u.pos() + u.view_offset;
3995 new_seen_mon.clear();
3996
3997 // TODO: no reason to have it static here
3998 static time_point previous_turn = calendar::start_of_cataclysm;
3999 const time_duration sm_ignored_time = time_duration::from_turns(
4000 get_option<int>( "SAFEMODEIGNORETURNS" ) );
4001
4003 monster *m = dynamic_cast<monster *>( c );
4004 npc *p = dynamic_cast<npc *>( c );
4005 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
4006 const int mx = POSX + ( c->posx() - view.x );
4007 const int my = POSY + ( c->posy() - view.y );
4008 int index = 8;
4009 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
4010 // for compatibility with old code, see diagram below, it explains the values for index,
4011 // also might need revisiting one z-levels are in.
4012 switch( dir_to_mon ) {
4016 index = 7;
4017 break;
4019 case direction::NORTH:
4021 index = 0;
4022 break;
4026 index = 1;
4027 break;
4029 case direction::WEST:
4031 index = 6;
4032 break;
4034 case direction::CENTER:
4036 index = 8;
4037 break;
4039 case direction::EAST:
4041 index = 2;
4042 break;
4046 index = 5;
4047 break;
4049 case direction::SOUTH:
4051 index = 4;
4052 break;
4056 index = 3;
4057 break;
4058 }
4059 }
4060
4061 rule_state safemode_state = RULE_NONE;
4062 const bool safemode_empty = get_safemode().empty();
4063
4064 if( m != nullptr ) {
4065 //Safemode monster check
4066 monster &critter = *m;
4067
4068 const monster_attitude matt = critter.attitude( &u );
4069 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4070 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4071
4072 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4073 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4074 if( index < 8 && critter.sees( g->u ) ) {
4075 dangerous[index] = true;
4076 }
4077
4078 if( !safemode_empty || mon_dist <= iProxyDist ) {
4079 bool passmon = false;
4080 if( critter.ignoring > 0 ) {
4081 if( safe_mode != SAFE_MODE_ON ) {
4082 critter.ignoring = 0;
4083 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4084 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4085 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4086 passmon = true;
4087 }
4088 critter.lastseen_turn = calendar::turn;
4089 }
4090
4091 if( !passmon ) {
4092 newseen++;
4093 new_seen_mon.push_back( shared_from( critter ) );
4094 }
4095 }
4096 }
4097
4098 std::vector<std::pair<const mtype *, int>> &vec = unique_mons[index];
4099 const auto mon_it = std::find_if( vec.begin(), vec.end(),
4100 [&]( const std::pair<const mtype *, int> &elem ) {
4101 return elem.first == critter.type;
4102 } );
4103 if( mon_it == vec.end() ) {
4104 vec.emplace_back( critter.type, 1 );
4105 } else {
4106 mon_it->second++;
4107 }
4108 } else if( p != nullptr ) {
4109 //Safe mode NPC check
4110
4111 const int npc_dist = rl_dist( u.pos(), p->pos() );
4112 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4113 npc_dist );
4114
4115 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4116 p->get_attitude() == NPCATT_KILL ) ) {
4117 if( !safemode_empty || npc_dist <= iProxyDist ) {
4118 newseen++;
4119 }
4120 }
4121 unique_types[index].push_back( p );
4122 }
4123 }
4124
4125 if( newseen > mostseen ) {
4126 if( newseen - mostseen == 1 ) {
4127 if( !new_seen_mon.empty() ) {
4128 monster &critter = *new_seen_mon.back();
4130 string_format( _( "%s spotted!" ), critter.name() ) );
4131 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4132 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4134 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4135 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4136 // Triffids present. We ain't got TIME to adrenaline comedown!
4137 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4138 u.mod_pain( 3 ); // Does take it out of you, though
4139 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4140 }
4141 }
4142 } else {
4143 //Hostile NPC
4145 _( "Hostile survivor spotted!" ) );
4146 }
4147 } else {
4149 }
4151 if( safe_mode == SAFE_MODE_ON ) {
4153 }
4154 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4155 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4156 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4157 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4159 add_msg( m_info, _( "Safe mode ON!" ) );
4160 }
4161 }
4162
4163 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4165 }
4166
4167 previous_turn = calendar::turn;
4168 mostseen = newseen;
4169}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1250
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1800
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1086
cata::optional< time_point > lastseen_turn
Definition: monster.h:509
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2077
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:277
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:55
@ MATT_FOLLOW
Definition: monster.h:61
@ MATT_ATTACK
Definition: monster.h:62
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4206 of file game.cpp.

4207{
4208 cleanup_dead();
4209
4210 for( monster &critter : all_monsters() ) {
4211 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4212 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4213 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4214 critter.pos().to_string(), m.tername( critter.pos() ) );
4215 dbg( DL::Error ) << msg;
4216 add_msg( m_debug, msg );
4217 bool okay = false;
4218 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4219 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4220 critter.setpos( dest );
4221 okay = true;
4222 break;
4223 }
4224 }
4225 if( !okay ) {
4226 // die of "natural" cause (overpopulation is natural)
4227 critter.die( nullptr );
4228 }
4229 }
4230
4231 if( !critter.is_dead() ) {
4232 critter.process_items();
4233 }
4234
4235 if( !critter.is_dead() ) {
4236 critter.process_turn();
4237 }
4238
4239 m.creature_in_field( critter );
4240 if( calendar::once_every( 1_days ) ) {
4241 if( critter.has_flag( MF_MILKABLE ) ) {
4242 critter.refill_udders();
4243 }
4244 critter.try_reproduce();
4245 }
4246 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4247 critter.made_footstep = false;
4248 // Controlled critters don't make their own plans
4249 if( !critter.has_effect( effect_ai_controlled ) ) {
4250 // Formulate a path to follow
4251 critter.plan();
4252 }
4253 critter.move(); // Move one square, possibly hit u
4254 critter.process_triggers();
4255 m.creature_in_field( critter );
4256 }
4257
4258 if( !critter.is_dead() &&
4259 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4260 u.get_power_level() >= 25_kJ &&
4261 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4262 !critter.is_hallucination() ) {
4263 u.mod_power_level( -25_kJ );
4264 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4266 _( "Your motion alarm goes off!" ) );
4267 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4268 u.wake_up();
4269 }
4270 }
4271 }
4272
4273 cleanup_dead();
4274
4275 // The remaining monsters are all alive, but may be outside of the reality bubble.
4276 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4277 // monster::die function is not called.
4278 for( monster &critter : all_monsters() ) {
4279 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4280 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4281 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4282 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4283 despawn_monster( critter );
4284 }
4285 }
4286
4287 // Now, do active NPCs.
4288 for( npc &guy : g->all_npcs() ) {
4289 int turns = 0;
4290 if( guy.is_mounted() ) {
4291 guy.check_mount_is_spooked();
4292 }
4293 m.creature_in_field( guy );
4294 if( !guy.has_effect( effect_npc_suspend ) ) {
4295 guy.process_turn();
4296 }
4297 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4298 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4299 ) {
4300 int moves = guy.moves;
4301 guy.move();
4302 if( moves == guy.moves ) {
4303 // Count every time we exit npc::move() without spending any moves.
4304 turns++;
4305 }
4306
4307 // Turn on debug mode when in infinite loop
4308 // It has to be done before the last turn, otherwise
4309 // there will be no meaningful debug output.
4310 if( turns == 9 ) {
4311 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4312 guy.name );
4313 debug_mode = true;
4314 }
4315 }
4316
4317 // If we spun too long trying to decide what to do (without spending moves),
4318 // Invoke cognitive suspension to prevent an infinite loop.
4319 if( turns == 10 ) {
4320 add_msg( _( "%s faints!" ), guy.name );
4321 guy.reboot();
4322 }
4323
4324 if( !guy.is_dead() ) {
4325 guy.npc_update_body();
4326 }
4327 }
4328 cleanup_dead();
4329}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1987
units::energy get_power_level() const
Definition: character.cpp:1967
void wake_up()
Definition: avatar.cpp:947
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), motion_alarm, calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2120 of file game.cpp.

2122{
2123 const int rate = get_option<int>( "EDGE_SCROLL" );
2124 auto ret = std::make_pair( tripoint_zero, last );
2125 if( rate == -1 ) {
2126 // Fast return when the option is disabled.
2127 return ret;
2128 }
2129 // Ensure the parameters are used even if the #if below is false
2130 ( void ) ctxt;
2131 ( void ) speed;
2132 ( void ) iso;
2133#if (defined TILES || defined _WIN32 || defined WINDOWS)
2134 auto now = std::chrono::steady_clock::now();
2135 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2136 return ret;
2137 } else {
2139 }
2140 const input_event event = ctxt.get_raw_input();
2141 if( event.type == CATA_INPUT_MOUSE ) {
2142 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2143 if( event.mouse_pos.x <= threshold.x ) {
2144 ret.first.x -= speed;
2145 if( iso ) {
2146 ret.first.y -= speed;
2147 }
2148 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2149 ret.first.x += speed;
2150 if( iso ) {
2151 ret.first.y += speed;
2152 }
2153 }
2154 if( event.mouse_pos.y <= threshold.y ) {
2155 ret.first.y -= speed;
2156 if( iso ) {
2157 ret.first.x += speed;
2158 }
2159 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2160 ret.first.y += speed;
2161 if( iso ) {
2162 ret.first.x -= speed;
2163 }
2164 }
2165 ret.second = ret.first;
2166 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2167 ret.first = ret.second;
2168 }
2169#endif
2170 return ret;
2171}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2182 of file game.cpp.

2183{
2184 // overmap has no iso mode
2188 return ret.first;
2189}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2120
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1090
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1091

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2173 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2554 of file game.cpp.

2555{
2556 const std::string save_dir = get_world_base_save_path();
2557 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2558 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2559 const std::string prefix = base64_encode( u.name ) + ".";
2560
2561 if( !assure_dir_exist( graveyard_dir ) ) {
2562 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2563 }
2564
2565 if( !assure_dir_exist( graveyard_save_dir ) ) {
2566 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2567 }
2568
2569 const auto save_files = get_files_from_path( prefix, save_dir );
2570 if( save_files.empty() ) {
2571 debugmsg( "could not find save files in '%s'", save_dir );
2572 }
2573
2574 for( const auto &src_path : save_files ) {
2575 const std::string dst_path = graveyard_save_dir +
2576 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2577
2578 if( rename_file( src_path, dst_path ) ) {
2579 continue;
2580 }
2581
2582 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2583
2584 if( remove_file( src_path ) ) {
2585 continue;
2586 }
2587
2588 debugmsg( "could not remove file '%s'", src_path );
2589 }
2590}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5228 of file game.cpp.

5229{
5230 const optional_vpart_position vp = m.veh_at( u.pos() );
5231 if( !vp ) {
5232 debugmsg( "Tried to exit non-existent vehicle." );
5233 return;
5234 }
5235 vehicle *const veh = &vp->vehicle();
5236 if( u.pos() == dest_loc ) {
5237 debugmsg( "Need somewhere to dismount towards." );
5238 return;
5239 }
5240 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5241 // TODO:: make dir() const correct!
5242 const units::angle d = ray.dir();
5243 add_msg( _( "You dive from the %s." ), veh->name );
5244 m.unboard_vehicle( u.pos() );
5245 u.moves -= 200;
5246 // Dive three tiles in the direction of tox and toy
5247 fling_creature( &u, d, 30, true );
5248 // Hit the ground according to vehicle speed
5249 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5250 if( veh->velocity > 0 ) {
5251 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5252 } else {
5253 fling_creature( &u, veh->face.dir() + 180_degrees,
5254 -( veh->velocity ) / static_cast<float>( 100 ) );
5255 }
5256 }
5257}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:9831

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3635 of file game.cpp.

3636{
3637 // ignore while underground or above limits
3638 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3639 return LIGHT_AMBIENT_MINIMAL;
3640 }
3641
3642 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3643 // Already found the light level for now?
3644 return latest_lightlevels[zlev];
3645 }
3646
3647 float ret = LIGHT_AMBIENT_MINIMAL;
3648
3649 // Sunlight/moonlight related stuff
3651 if( !weather.lightning_active ) {
3653 } else {
3654 // Recent lightning strike has lit the area
3656 }
3657
3659
3660 // Artifact light level changes here. Even though some of these only have an effect
3661 // aboveground it is cheaper performance wise to simply iterate through the entire
3662 // list once instead of twice.
3663 float mod_ret = -1;
3664 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3665 // will trump a lower one.
3666 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3667 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3668 const time_duration left = e->when - calendar::turn;
3669 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3670 if( left > 25_turns ) {
3671 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3672 // and the last 25 scale back towards normal.
3673 } else {
3674 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3675 }
3676 }
3678 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3679 mod_ret = std::max<float>( ret, default_daylight_level() );
3680 }
3681 // If we had a changed light level due to an artifact event then it overwrites
3682 // the natural light level.
3683 if( mod_ret > -1 ) {
3684 ret = mod_ret;
3685 }
3686
3687 // Cap everything to our minimum light level
3688 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3689
3690 latest_lightlevels[zlev] = ret;
3691
3692 return ret;
3693}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1063
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5359 of file game.cpp.

5360{
5361 enum choices : int {
5362 talk = 0,
5363 swap_pos,
5364 push,
5365 examine_wounds,
5366 use_item,
5367 sort_armor,
5368 attack,
5369 disarm,
5370 steal
5371 };
5372
5373 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5374
5375 uilist amenu;
5376
5377 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5378 amenu.addentry( talk, true, 't', _( "Talk" ) );
5379 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5380 !u.is_mounted(), 's', _( "Swap positions" ) );
5381 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5382 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5383 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5384 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5385 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5386 if( !who.is_player_ally() ) {
5387 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5388 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5389 }
5390
5391 amenu.query();
5392
5393 const int choice = amenu.ret;
5394 if( choice == talk ) {
5395 who.talk_to_u();
5396 } else if( choice == swap_pos ) {
5397 if( !prompt_dangerous_tile( who.pos() ) ) {
5398 return true;
5399 }
5400 // TODO: Make NPCs protest when displaced onto dangerous crap
5401 add_msg( _( "You swap places with %s." ), who.name );
5402 swap_critters( u, who );
5403 // TODO: Make that depend on stuff
5404 u.mod_moves( -200 );
5405 } else if( choice == push ) {
5406 // TODO: Make NPCs protest when displaced onto dangerous crap
5407 tripoint oldpos = who.pos();
5408 who.move_away_from( u.pos(), true );
5409 u.mod_moves( -20 );
5410 if( oldpos != who.pos() ) {
5411 add_msg( _( "%s moves out of the way." ), who.name );
5412 } else {
5413 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5414 }
5415 } else if( choice == examine_wounds ) {
5416 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5417
5418 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5419 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5420 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5421 0.0f, 0.0f );
5422 } else if( choice == use_item ) {
5423 static const std::string heal_string( "heal" );
5424 const auto will_accept = []( const item & it ) {
5425 const auto use_fun = it.get_use( heal_string );
5426 if( use_fun == nullptr ) {
5427 return false;
5428 }
5429
5430 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5431
5432 return actor != nullptr &&
5433 actor->limb_power >= 0 &&
5434 actor->head_power >= 0 &&
5435 actor->torso_power >= 0;
5436 };
5437 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5438
5439 if( !loc ) {
5440 add_msg( _( "Never mind" ) );
5441 return false;
5442 }
5443 item &used = *loc;
5444 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5445 if( did_use ) {
5446 // Note: exiting a body part selection menu counts as use here
5447 u.mod_moves( -300 );
5448 }
5449 } else if( choice == sort_armor ) {
5450 who.sort_armor();
5451 u.mod_moves( -100 );
5452 } else if( choice == attack ) {
5453 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5454 u.melee_attack( who, true );
5455 who.on_attacked( u );
5456 }
5457 } else if( choice == disarm ) {
5458 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5459 u.disarm( who );
5460 }
5461 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5462 u.steal( who );
5463 }
5464
5465 return true;
5466}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5848
bool in_sleep_state() const override
Definition: character.cpp:9320
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:250
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2390
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8771
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:4885
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:731
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1449
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2535
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2314
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:604

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 4830 of file game.cpp.

4831{
4832 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
4833}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 9789 of file game.cpp.

9790{
9791 // TODO: Move this to a character method
9792 if( !u.is_mounted() ) {
9793 const item muscle( "muscle" );
9794 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
9795 if( u.has_active_bionic( bid ) ) {// active power gen
9796 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
9797 } else if( u.has_bionic( bid ) ) {// passive power gen
9798 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
9799 }
9800 }
9801
9802 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
9803 if( u.movement_mode_is( CMM_RUN ) ) {
9804 u.mod_power_level( -55_J );
9805 } else {
9806 u.mod_power_level( -35_J );
9807 }
9808 }
9809 }
9810
9811 if( u.movement_mode_is( CMM_RUN ) ) {
9812 if( !u.can_run() ) {
9814 }
9815 }
9816
9817 // apply martial art move bonuses
9818 u.martial_arts_data->ma_onmove_effects( u );
9819
9821}
@ CMM_RUN
Definition: character.h:103
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1329
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1619
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1928
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1877
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 9823 of file game.cpp.

9824{
9825#if defined(TILES)
9826 tilecontext->on_options_changed();
9827#endif
9828 grid_tracker_ptr->on_options_changed();
9829}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1488 of file handle_action.cpp.

1489{
1490 uilist as_m;
1491
1492 as_m.text = _( "What do you want to consume?" );
1493
1494 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1495 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1496 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1497 as_m.query();
1498
1499 switch( as_m.ret ) {
1500 case 0:
1502 break;
1503 case 1:
1505 break;
1506 case 2:
1508 break;
1509 default:
1510 break;
1511 }
1512}
std::vector< uilist_entry > entries
Definition: ui.h:323
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ open_gate()

void game::open_gate ( const tripoint p)

Definition at line 5223 of file game.cpp.

5224{
5225 gates::open_gate( p, u );
5226}
void open_gate(const tripoint &pos, player &p)
opens the gate via player's activity
Definition: gates.cpp:236

References gates::open_gate(), and u.

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4331 of file game.cpp.

4332{
4333 std::vector<npc *> travelling_npcs;
4334 static constexpr int move_search_radius = 600;
4335 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4336 if( !elem ) {
4337 continue;
4338 }
4339 npc *npc_to_add = elem.get();
4340 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4341 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4342 travelling_npcs.push_back( npc_to_add );
4343 }
4344 }
4345 for( auto &elem : travelling_npcs ) {
4346 if( elem->has_omt_destination() ) {
4347 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4348 //recalculate path, we got distracted doing something else probably
4349 elem->omt_path.clear();
4350 }
4351 if( elem->omt_path.empty() ) {
4352 const tripoint_abs_omt &from = elem->global_omt_location();
4353 const tripoint_abs_omt &to = elem->goal;
4354 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4356 if( elem->omt_path.empty() ) {
4357 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4358 elem->get_name(), from.to_string(), to.to_string() );
4359 elem->goal = npc::no_goal_point;
4360 elem->mission = NPC_MISSION_NULL;
4361 }
4362 } else {
4363 if( elem->omt_path.back() == elem->global_omt_location() ) {
4364 elem->omt_path.pop_back();
4365 }
4366 // TODO: fix point types
4367 elem->travel_overmap(
4368 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4369 }
4370 reload_npcs();
4371 }
4372 }
4373 return;
4374}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:970
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2195
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5718 of file game.cpp.

5719{
5720 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5721 if( !p ) {
5722 return;
5723 }
5724
5725 if( p->z != 0 ) {
5726 const tripoint old_pos = u.pos();
5727 vertical_move( p->z, false, true );
5728
5729 if( old_pos != u.pos() ) {
5730 look_around();
5731 vertical_move( p->z * -1, false, true );
5732 }
5733 return;
5734 }
5735
5736 if( m.impassable( u.pos() + *p ) || m.obstructed_by_vehicle_rotation( u.pos(), u.pos() + *p ) ) {
5737 return;
5738 }
5739
5740 peek( u.pos() + *p );
5741}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:977

References _, choose_direction(), map::impassable(), look_around(), m, map::obstructed_by_vehicle_rotation(), peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5743 of file game.cpp.

5744{
5745 u.moves -= 200;
5746 tripoint prev = u.pos();
5747 u.setpos( p );
5748 tripoint center = p;
5749 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5750 true );
5751 u.setpos( prev );
5752
5753 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5754 item_location loc;
5755 avatar_action::plthrow( u, loc, p );
5756 }
5758}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11119 of file game.cpp.

11120{
11121 if( !calendar::once_every( 1_hours ) ) {
11122 return;
11123 }
11124 // Create a new NPC?
11125 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11126 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11127 return;
11128 }
11129
11130 float density = get_option<float>( "NPC_DENSITY" );
11131 static constexpr int density_search_radius = 60;
11132 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11133 if( npc_num > 0.0 ) {
11134 // 100%, 80%, 64%, 52%, 41%, 33%...
11135 density *= std::pow( 0.8f, npc_num );
11136 }
11137
11138 if( !x_in_y( density, 100 ) ) {
11139 return;
11140 }
11141 bool spawn_allowed = false;
11143 int counter = 0;
11144 while( !spawn_allowed ) {
11145 if( counter >= 10 ) {
11146 return;
11147 }
11148 static constexpr int radius_spawn_range = 120;
11149 const tripoint_abs_omt u_omt = u.global_omt_location();
11150 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11151 rng( -radius_spawn_range, radius_spawn_range ) );
11152 spawn_point.z() = 0;
11153 const oter_id oter = overmap_buffer.ter( spawn_point );
11154 // shouldn't spawn on lakes or rivers.
11155 if( !is_river_or_lake( oter ) ) {
11156 spawn_allowed = true;
11157 }
11158 counter += 1;
11159 }
11160 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11161 tmp->normalize();
11162 tmp->randomize();
11163 std::string new_fac_id = "solo_";
11164 new_fac_id += tmp->name;
11165 // create a new "lone wolf" faction for this one NPC
11166 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11167 faction_id( "no_faction" ) );
11168 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11169 // adds the npc to the correct overmap.
11170 // Only spawn random NPCs on z-level 0
11171 // TODO: fix point types
11172 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11173 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11175 tmp->form_opinion( u );
11176 tmp->mission = NPC_MISSION_NULL;
11177 tmp->long_term_goal_action();
11178 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11179 tmp->getID() ) );
11180 // This will make the new NPC active- if its nearby to the player
11181 load_npcs();
11182}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 9521 of file game.cpp.

9522{
9523 if( dest_loc.z != u.posz() && !via_ramp ) {
9524 // No vertical phasing yet
9525 return false;
9526 }
9527
9528 //probability travel through walls but not water
9529 tripoint dest = dest_loc;
9530 // tile is impassable
9531 int tunneldist = 0;
9532 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
9533 while( m.impassable( dest ) ||
9534 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
9535 //add 1 to tunnel distance for each impassable tile in the line
9536 tunneldist += 1;
9537 //Being dimensionally anchored prevents quantum shenanigans.
9538 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
9540 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
9541 return false;
9542 }
9543
9544 if( tunneldist > 24 ) {
9545 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
9546 return false;
9547 }
9548
9549 dest.x += d.x;
9550 dest.y += d.y;
9551 }
9552
9553 if( tunneldist != 0 ) {
9554 if( ( tunneldist - 1 ) * 100_kJ
9555 > //The first 100 was already taken up by the bionic's activation cost.
9556 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
9557 if( tunneldist * 100_kJ >
9559 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
9560 } else {
9561 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
9562 ( 100 * tunneldist ) );
9563 }
9564 return false;
9565 }
9566
9567 if( u.in_vehicle ) {
9568 m.unboard_vehicle( u.pos() );
9569 }
9570
9571 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
9572 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
9573 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
9574 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
9575 u.moves -= ( 50 + ( tunneldist * 50 ) );
9576 u.setpos( dest );
9577
9578 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
9579 m.board_vehicle( u.pos(), &u );
9580 }
9581
9582 u.grab( OBJECT_NONE );
9584 m.creature_on_trap( u );
9585 return true;
9586 }
9587
9588 return false;
9589}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3270
units::energy get_max_power_level() const
Definition: character.cpp:1972
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1201
void on_move_effects()
Definition: game.cpp:9789
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1046
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5689 of file game.cpp.

5690{
5691 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5692 _( "There is nothing to pick up nearby." ),
5693 ACTION_PICKUP, false );
5694 if( !examp_ ) {
5695 return;
5696 }
5697 pickup( *examp_ );
5698}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5700 of file game.cpp.

5701{
5702 // Highlight target
5703 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5704 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5705 } );
5706 add_draw_callback( hilite_cb );
5707
5708 pickup::pick_up( p, 0 );
5709}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5711 of file game.cpp.

5712{
5713 pickup::pick_up( u.pos(), 1 );
5714}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4778 of file game.cpp.

4779{
4780 // TODO: change this into an assert, it must never happen.
4781 if( id.is_null() ) {
4782 return nullptr;
4783 }
4784 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4785}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4778

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4787 of file game.cpp.

4791{
4793 if( forced || can_place_monster( *mon, center ) ) {
4794 where = center;
4795 }
4796
4797 // This loop ensures the monster is placed as close to the center as possible,
4798 // but all places that equally far from the center have the same probability.
4799 for( int r = 1; r <= radius && !where; ++r ) {
4801 }
4802
4803 if( !where ) {
4804 return nullptr;
4805 }
4806 mon->spawn( *where );
4807 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4808}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4760
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4744

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4768 of file game.cpp.

4769{
4770 return place_critter_around( id, p, 0 );
4771}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4773 of file game.cpp.

4774{
4775 return place_critter_around( mon, p, 0 );
4776}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 4810 of file game.cpp.

4811{
4812 // TODO: change this into an assert, it must never happen.
4813 if( id.is_null() ) {
4814 return nullptr;
4815 }
4816 return place_critter_within( make_shared_fast<monster>( id ), range );
4817}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:4810

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 4819 of file game.cpp.

4821{
4822 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
4823 if( !where ) {
4824 return nullptr;
4825 }
4826 mon->spawn( *where );
4827 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4828}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9159 of file game.cpp.

9160{
9161 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9162 if( const cata::optional<std::string> label = vp1.get_label() ) {
9163 add_msg( m_info, _( "Label here: %s" ), *label );
9164 }
9165 std::string signage = m.get_signage( dest_loc );
9166 if( !signage.empty() ) {
9167 if( !u.has_trait( trait_ILLITERATE ) ) {
9168 add_msg( m_info, _( "The sign says: %s" ), signage );
9169 } else {
9170 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9171 }
9172 }
9173 if( m.has_graffiti_at( dest_loc ) ) {
9174 if( !u.has_trait( trait_ILLITERATE ) ) {
9175 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9176 } else {
9177 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9178 }
9179 }
9180 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9181 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9182 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9183 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9184 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9185 dest_loc ) );
9186 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9187 }
9188 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9189 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9190 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9191 dest_loc ) );
9192 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9193 }
9194 }
9195 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9196 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9197 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9198 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9199 if( u.is_mounted() ) {
9200 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9201 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9202 } else {
9203 const bodypart_id bp = u.get_random_body_part();
9204 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9205 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9206 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9207 body_part_name_accusative( bp->token ),
9208 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9209 dest_loc ) );
9210 }
9211 }
9212 }
9213 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9214 u.add_effect( effect_bouldering, 1_turns, num_bp );
9215 } else if( u.has_effect( effect_bouldering ) ) {
9217 }
9218 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9219 u.add_effect( effect_no_sight, 1_turns, num_bp );
9220 } else if( u.has_effect( effect_no_sight ) ) {
9222 }
9223
9224 // If we moved out of the nonant, we need update our map data
9225 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9226 add_msg( _( "The water puts out the flames!" ) );
9228 if( u.is_mounted() ) {
9229 monster *mon = u.mounted_creature.get();
9230 if( mon->has_effect( effect_onfire ) ) {
9232 }
9233 }
9234 }
9235
9236 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9237 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9238 // Immobile monsters can't be displaced.
9239 monster &critter = *mon_ptr;
9240 // TODO: handling for ridden creatures other than players mount.
9241 if( !critter.has_effect( effect_ridden ) ) {
9242 if( u.is_mounted() ) {
9243 std::vector<tripoint> valid;
9244 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9245 if( is_empty( jk ) ) {
9246 valid.push_back( jk );
9247 }
9248 }
9249 if( !valid.empty() ) {
9250 critter.move_to( random_entry( valid ) );
9251 add_msg( _( "You push the %s out of the way." ), critter.name() );
9252 } else {
9253 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9254 return u.pos().xy();
9255 }
9256 } else {
9257 critter.move_to( u.pos(), false,
9258 true ); // Force the movement even though the player is there right now.
9259 add_msg( _( "You displace the %s." ), critter.name() );
9260 }
9261 } else if( !u.has_effect( effect_riding ) ) {
9262 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9263 return u.pos().xy();
9264 }
9265 }
9266
9267 // If the player is in a vehicle, unboard them from the current part
9268 if( u.in_vehicle ) {
9269 m.unboard_vehicle( u.pos() );
9270 }
9271 // Move the player
9272 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9273 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9274 vertical_shift( dest_loc.z );
9275 }
9276
9277 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9278 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9279 vp1 ) ) {
9280 u.stop_hauling();
9281 }
9282 u.setpos( dest_loc );
9283 if( u.is_mounted() ) {
9284 monster *mon = u.mounted_creature.get();
9285 mon->setpos( dest_loc );
9286 mon->process_triggers();
9287 m.creature_in_field( *mon );
9288 }
9289 point submap_shift = update_map( u );
9290 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9291 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9292 // If you must use it you can calculate the position in the new, shifted system with
9293 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9294
9295 //Auto pulp or butcher and Auto foraging
9296 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9298
9299 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9300 if( forage_type != "off" ) {
9301 const auto forage = [&]( const tripoint & pos ) {
9302 const auto &xter_t = m.ter( pos ).obj().examine;
9303 const auto &xfurn_t = m.furn( pos ).obj().examine;
9304 const bool forage_everything = forage_type == "both";
9305 const bool forage_bushes = forage_everything || forage_type == "bushes";
9306 const bool forage_trees = forage_everything || forage_type == "trees";
9307 if( xter_t == &iexamine::none ) {
9308 return;
9309 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9310 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9311 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9312 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9313 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9314 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9315 ) {
9316 xter_t( u, pos );
9317 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9318 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9319 ) {
9320 xfurn_t( u, pos );
9321 }
9322 };
9323
9324 for( auto &elem : adjacentDir ) {
9325 forage( u.pos() + direction_XY( elem ) );
9326 }
9327 }
9328
9329 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9330 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9331 std::vector<item *> corpses;
9332
9333 for( item &it : m.i_at( u.pos() ) ) {
9334 corpses.push_back( &it );
9335 }
9336
9337 if( !corpses.empty() ) {
9338 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9339 for( item *it : corpses ) {
9340 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9341 }
9342 }
9343 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9344 const auto pulp = [&]( const tripoint & pos ) {
9345 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9346 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9347 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9349 u.activity.placement = m.getabs( pos );
9350 u.activity.auto_resume = true;
9351 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9352 return;
9353 }
9354 }
9355 };
9356
9357 if( pulp_butcher == "pulp_adjacent" ) {
9358 for( auto &elem : adjacentDir ) {
9359 pulp( u.pos() + direction_XY( elem ) );
9360 }
9361 } else {
9362 pulp( u.pos() );
9363 }
9364 }
9365 }
9366
9367 //Autopickup
9368 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9369 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9370 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9371 pickup::pick_up( u.pos(), -1 );
9372 }
9373
9374 // If the new tile is a boardable part, board it
9375 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9376 m.board_vehicle( u.pos(), &u );
9377 }
9378
9379 // Traps!
9380 // Try to detect.
9382 if( u.is_mounted() ) {
9384 } else {
9385 m.creature_on_trap( u );
9386 }
9387 // Drench the player if swimmable
9388 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9389 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9390 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9391 }
9392
9393 // List items here
9394 if( !m.has_flag( "SEALED", u.pos() ) ) {
9395 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9396 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9397 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9398 add_msg( _( "There's something here, but you can't see what it is." ) );
9399 } else if( m.has_items( u.pos() ) ) {
9400 std::vector<std::string> names;
9401 std::vector<size_t> counts;
9402 std::vector<item> items;
9403 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9404
9405 std::string next_tname = tmpitem.tname();
9406 std::string next_dname = tmpitem.display_name();
9407 bool by_charges = tmpitem.count_by_charges();
9408 bool got_it = false;
9409 for( size_t i = 0; i < names.size(); ++i ) {
9410 if( by_charges && next_tname == names[i] ) {
9411 counts[i] += tmpitem.charges;
9412 got_it = true;
9413 break;
9414 } else if( next_dname == names[i] ) {
9415 counts[i] += 1;
9416 got_it = true;
9417 break;
9418 }
9419 }
9420 if( !got_it ) {
9421 if( by_charges ) {
9422 names.push_back( tmpitem.tname( tmpitem.charges ) );
9423 counts.push_back( tmpitem.charges );
9424 } else {
9425 names.push_back( tmpitem.display_name( 1 ) );
9426 counts.push_back( 1 );
9427 }
9428 items.push_back( tmpitem );
9429 }
9430 if( names.size() > 10 ) {
9431 break;
9432 }
9433 }
9434 for( size_t i = 0; i < names.size(); ++i ) {
9435 if( !items[i].count_by_charges() ) {
9436 names[i] = items[i].display_name( counts[i] );
9437 } else {
9438 names[i] = items[i].tname( counts[i] );
9439 }
9440 }
9441 int and_the_rest = 0;
9442 for( size_t i = 0; i < names.size(); ++i ) {
9443 //~ number of items: "<number> <item>"
9444 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9445 names[i] = string_format( fmt, counts[i], names[i] );
9446 // Skip the first two.
9447 if( i > 1 ) {
9448 and_the_rest += counts[i];
9449 }
9450 }
9451 if( names.size() == 1 ) {
9452 add_msg( _( "You see here %s." ), names[0] );
9453 } else if( names.size() == 2 ) {
9454 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9455 } else if( names.size() == 3 ) {
9456 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9457 } else if( and_the_rest < 7 ) {
9458 add_msg( vgettext( "You see here %s, %s and %d more item.",
9459 "You see here %s, %s and %d more items.",
9460 and_the_rest ),
9461 names[0], names[1], and_the_rest );
9462 } else {
9463 add_msg( _( "You see here %s and many more items." ), names[0] );
9464 }
9465 }
9466 }
9467 }
9468
9469 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9470 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9471 add_msg( _( "There are vehicle controls here." ) );
9472 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9473 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9474 }
9475 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9476 u.is_mounted() ) {
9477 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9478 }
9479 return submap_shift;
9480}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1752
bool is_hauling() const
Definition: character.cpp:9184
void stop_hauling()
Definition: character.cpp:9175
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1620
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:10642
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6099
std::string furnname(const tripoint &p)
Definition: map.cpp:1466
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2319
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7821
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4752
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7810
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2309
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2295
void setpos(const tripoint &p) override
Definition: monster.cpp:238
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1517
void process_triggers()
Definition: monster.cpp:1212
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:701
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3658
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3623
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2095
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2074
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2083
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2065
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3637
string_id< zone_type > zone_type_id
Definition: type_id.h:199

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9482 of file game.cpp.

9483{
9484 // if player is teleporting around, they don't bring their horse with them
9485 if( u.is_mounted() ) {
9487 u.mounted_creature->remove_effect( effect_ridden );
9488 u.mounted_creature = nullptr;
9489 }
9490 // offload the active npcs.
9491 unload_npcs();
9492 for( monster &critter : all_monsters() ) {
9493 despawn_monster( critter );
9494 }
9495 if( u.in_vehicle ) {
9496 m.unboard_vehicle( u.pos() );
9497 }
9498
9500 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9501 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9502 for( int z = minz; z <= maxz; z++ ) {
9503 m.clear_vehicle_list( z );
9504 }
9506 // offset because load_map expects the coordinates of the top left corner, but the
9507 // player will be centered in the middle of the map.
9508 // TODO: fix point types
9509 const tripoint map_sm_pos(
9510 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9511 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9512 load_map( map_sm_pos );
9513 load_npcs();
9514 m.spawn_monsters( true ); // Static monsters
9516 // update weather now as it could be different on the new location
9518 place_player( player_pos );
9519}
point place_player(const tripoint &dest)
Definition: game.cpp:9159
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:959
void update_overmap_seen()
Definition: game.cpp:10820
level_cache & access_cache(int zlev)
Definition: map.cpp:8693
void clear_vehicle_list(int zlev)
Definition: map.cpp:329
void clear_vehicle_cache()
Definition: map.cpp:311
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:356

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 855 of file game.cpp.

858{
859 std::vector<std::string> search_types = omt_search_types;
860 if( search_types.empty() ) {
861 vehicle veh( id );
862 if( veh.can_float() ) {
863 search_types.push_back( "river" );
864 search_types.push_back( "lake" );
865 } else {
866 search_types.push_back( "field" );
867 search_types.push_back( "road" );
868 }
869 }
870 for( const std::string &search_type : search_types ) {
871 omt_find_params find_params;
872 find_params.must_see = false;
873 find_params.cant_see = false;
874 find_params.types.emplace_back( search_type, ot_match_type::type );
875 // find nearest road
876 find_params.min_distance = min_distance;
877 find_params.search_range = max_distance;
878 // if player spawns underground, park their car on the surface.
879 const tripoint_abs_omt omt_origin( origin, 0 );
880 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
881 // try place vehicle there.
882 tinymap target_map;
883 target_map.load( project_to<coords::sm>( goal ), false );
884 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
885 static constexpr std::array<units::angle, 4> angles = {{
886 0_degrees, 90_degrees, 180_degrees, 270_degrees
887 }
888 };
889 vehicle *veh = target_map.add_vehicle(
890 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
891 if( veh ) {
892 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
893 veh->sm_pos = ms_to_sm_remain( abs_local );
894 veh->pos = abs_local.xy();
896 veh->tracking_on = true;
897 target_map.save();
898 return veh;
899 }
900 }
901 }
902 return nullptr;
903}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6586
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5600
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2095
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1916
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1901
bool tracking_on
Definition: vehicle.h:1991
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6641 of file game.cpp.

6644{
6645 // get global area info according to look_around caret position
6646 // TODO: fix point types
6648 lp ) ) ) );
6649 // we only need the area name and then pass it to print_all_tile_info() function below
6650 const std::string area_name = cur_ter_m->get_name();
6651 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6652}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:5821
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 5821 of file game.cpp.

5826{
5827 visibility_type visibility = VIS_HIDDEN;
5828 const bool inbounds = m.inbounds( lp );
5829 if( inbounds ) {
5830 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5831 }
5832 const Creature *creature = critter_at( lp, true );
5833 switch( visibility ) {
5834 case VIS_CLEAR: {
5835 const optional_vpart_position vp = m.veh_at( lp );
5836 print_terrain_info( lp, w_look, area_name, column, line );
5837 print_fields_info( lp, w_look, column, line );
5838 print_trap_info( lp, w_look, column, line );
5839 print_creature_info( creature, w_look, column, line, last_line );
5840 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
5841 last_line );
5842 print_items_info( lp, w_look, column, line, last_line );
5843 print_graffiti_info( lp, w_look, column, line, last_line );
5844 }
5845 break;
5846 case VIS_BOOMER:
5847 case VIS_BOOMER_DARK:
5848 case VIS_DARK:
5849 case VIS_LIT:
5850 case VIS_HIDDEN:
5851 print_visibility_info( w_look, column, line, visibility );
5852
5853 if( creature != nullptr ) {
5854 std::vector<std::string> buf;
5855 if( u.sees_with_infrared( *creature ) ) {
5856 creature->describe_infrared( buf );
5857 } else if( u.sees_with_specials( *creature ) ) {
5858 creature->describe_specials( buf );
5859 }
5860 for( const std::string &s : buf ) {
5861 mvwprintw( w_look, point( 1, ++line ), s );
5862 }
5863 }
5864 break;
5865 }
5866 if( !inbounds ) {
5867 return;
5868 }
5869 auto this_sound = sounds::sound_at( lp );
5870 if( !this_sound.empty() ) {
5871 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
5872 } else {
5873 // Check other z-levels
5874 tripoint tmp = lp;
5875 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
5876 if( tmp.z == lp.z ) {
5877 continue;
5878 }
5879
5880 auto zlev_sound = sounds::sound_at( tmp );
5881 if( !zlev_sound.empty() ) {
5882 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
5883 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
5884 }
5885 }
5886 }
5887}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6425
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:5991
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:5918
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6083
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6028
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6037
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6046
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:5889
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6009
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6455
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6028 of file game.cpp.

6030{
6031 int vLines = last_line - line;
6032 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
6033 line = creature->print_info( w_look, ++line, vLines, column );
6034 }
6035}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 5991 of file game.cpp.

5993{
5994 const field &tmpfield = m.field_at( lp );
5995 for( auto &fld : tmpfield ) {
5996 const field_entry &cur = fld.second;
5997 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
5998 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
5999 const int max_width = getmaxx( w_look ) - column - 2;
6000 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
6001 get_fire_fuel_string( lp ) ) - 1;
6002 line += lines;
6003 } else {
6004 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
6005 }
6006 }
6007}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6083 of file game.cpp.

6086{
6087 if( line > last_line ) {
6088 return;
6089 }
6090
6091 const int max_width = getmaxx( w_look ) - column - 2;
6092 if( m.has_graffiti_at( lp ) ) {
6093 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6094 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6095 m.graffiti_at( lp ) );
6096 }
6097}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6046 of file game.cpp.

6049{
6050 if( !m.sees_some_items( lp, u ) ) {
6051 return;
6052 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6053 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6054 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6055 mvwprintz( w_look, point( column, ++line ), c_yellow,
6056 _( "There's something there, but you can't see what it is." ) );
6057 return;
6058 } else {
6059 std::map<std::string, int> item_names;
6060 for( auto &item : m.i_at( lp ) ) {
6061 ++item_names[item.tname()];
6062 }
6063
6064 const int max_width = getmaxx( w_look ) - column - 1;
6065 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6066 // last line but not last item
6067 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6068 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6069 break;
6070 }
6071
6072 if( it->second > 1 ) {
6073 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6074 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6075 it->first.c_str(), it->second );
6076 } else {
6077 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6078 }
6079 }
6080 }
6081}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4728
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 5918 of file game.cpp.

5921{
5922 const int max_width = getmaxx( w_look ) - column - 1;
5923 int lines;
5924
5925 const auto fmt_tile_info = []( const tripoint & lp ) {
5926 map &here = get_map();
5927 std::string ret;
5928 if( debug_mode ) {
5929 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
5930 if( here.has_furn( lp ) ) {
5931 ret += "; " + here.furn( lp )->id.str();
5932 }
5933 } else {
5934 ret = here.tername( lp );
5935 if( here.has_furn( lp ) ) {
5936 ret += "; " + here.furnname( lp );
5937 }
5938 }
5939 return ret;
5940 };
5941
5942 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
5943
5944 if( m.impassable( lp ) ) {
5945 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5946 _( "%s; Impassable" ),
5947 tile );
5948 } else {
5949 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5950 _( "%s; Movement cost %d" ),
5951 tile, m.move_cost( lp ) * 50 );
5952
5953 const auto ll = get_light_level( std::max( 1.0,
5954 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
5955 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
5956 wprintz( w_look, ll.second, ll.first );
5957 }
5958
5959 std::string signage = m.get_signage( lp );
5960 if( !signage.empty() ) {
5961 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5962 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
5963 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
5964 }
5965
5966 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
5967 // Print info about stuff below
5968 tripoint below( lp.xy(), lp.z - 1 );
5969 std::string tile_below = fmt_tile_info( below );
5970
5971 if( !m.has_floor_or_support( lp ) ) {
5972 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5973 _( "Below: %s; No support" ),
5974 tile_below );
5975 } else {
5976 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5977 _( "Below: %s; Walkable" ),
5978 tile_below );
5979 }
5980 }
5981
5982 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5983 m.features( lp ) );
5984 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
5985 m.coverage( lp ) );
5986 if( line < lines ) {
5987 line = lines + map_features - 1;
5988 }
5989}
Manage and cache data about a part of the map.
Definition: map.h:389
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2036
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:617
std::string features(const tripoint &p)
Definition: map.cpp:1711
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6236
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:496
ter_str_id id
Definition: mapdata.h:461

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6009 of file game.cpp.

6011{
6012 const trap &tr = m.tr_at( lp );
6013 if( tr.can_see( lp, u ) ) {
6014 partial_con *pc = m.partial_con_at( lp );
6015 std::string tr_name;
6016 if( pc && tr.loadid == tr_unfinished_construction ) {
6017 const construction &built = pc->id.obj();
6018 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.group->name(),
6019 pc->counter / 100000 );
6020 } else {
6021 tr_name = tr.name();
6022 }
6023
6024 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
6025 }
6026}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5133
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string name() const
construction_group_str_id group
Definition: construction.h:50
construction_id id
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::group, partial_con::id, line(), trap::loadid, m, mvwprintz(), construction_group::name(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6037 of file game.cpp.

6039{
6040 if( veh ) {
6041 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6042 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6043 }
6044}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 5889 of file game.cpp.

5891{
5892 const char *visibility_message = nullptr;
5893 switch( visibility ) {
5894 case VIS_CLEAR:
5895 visibility_message = _( "Clearly visible." );
5896 break;
5897 case VIS_BOOMER:
5898 visibility_message = _( "A bright pink blur." );
5899 break;
5900 case VIS_BOOMER_DARK:
5901 visibility_message = _( "A pink blur." );
5902 break;
5903 case VIS_DARK:
5904 visibility_message = _( "Darkness." );
5905 break;
5906 case VIS_LIT:
5907 visibility_message = _( "Bright light." );
5908 break;
5909 case VIS_HIDDEN:
5910 visibility_message = _( "Unseen." );
5911 break;
5912 }
5913
5914 mvwprintw( w_look, point( line, column ), visibility_message );
5915 line += 2;
5916}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1750 of file game.cpp.

1751{
1752 if( !u.activity ) {
1753 return;
1754 }
1755
1756 while( u.moves > 0 && u.activity ) {
1757 u.activity.do_turn( u );
1758 }
1759}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11393 of file game.cpp.

11394{
11395 const bool worn = p.is_worn( it );
11396 const bool wielded = ( &it == &p.weapon );
11397 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11398 if( worn ) {
11399 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11400 effects.insert( effects.end(), ew.begin(), ew.end() );
11401 }
11402 if( wielded ) {
11403 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11404 effects.insert( effects.end(), ew.begin(), ew.end() );
11405 }
11406
11407 if( it.is_tool() ) {
11408 // Recharge it if necessary
11409 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11410 //Before incrementing charge, check that any extra requirements are met
11411 if( check_art_charge_req( it ) ) {
11412 switch( it.type->artifact->charge_type ) {
11413 case ARTC_NULL:
11414 case NUM_ARTCS:
11415 break; // dummy entries
11416 case ARTC_TIME:
11417 // Once per hour
11418 if( calendar::once_every( 1_hours ) ) {
11419 it.charges++;
11420 }
11421 break;
11422 case ARTC_SOLAR:
11423 if( calendar::once_every( 10_minutes ) &&
11424 is_in_sunlight( p.pos() ) ) {
11425 it.charges++;
11426 }
11427 break;
11428 // Artifacts can inflict pain even on Deadened folks.
11429 // Some weird Lovecraftian thing. ;P
11430 // (So DON'T route them through mod_pain!)
11431 case ARTC_PAIN:
11432 if( calendar::once_every( 1_minutes ) ) {
11433 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11434 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11435 it.charges++;
11436 }
11437 break;
11438 case ARTC_HP:
11439 if( calendar::once_every( 1_minutes ) ) {
11440 add_msg( m_bad, _( "You feel your body decaying." ) );
11441 p.hurtall( 1, nullptr );
11442 it.charges++;
11443 }
11444 break;
11445 case ARTC_FATIGUE:
11446 if( calendar::once_every( 1_minutes ) ) {
11447 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11448 u.mod_fatigue( 3 * rng( 1, 3 ) );
11449 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11450 it.charges++;
11451 }
11452 break;
11453 // Portals are energetic enough to charge the item.
11454 // Tears in reality are consumed too, but can't charge it.
11455 case ARTC_PORTAL:
11456 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11457 m.remove_field( dest, fd_fatigue );
11458 if( m.tr_at( dest ).loadid == tr_portal ) {
11459 add_msg( m_good, _( "The portal collapses!" ) );
11460 m.remove_trap( dest );
11461 it.charges++;
11462 break;
11463 }
11464 }
11465 break;
11466 }
11467 }
11468 }
11469 }
11470
11471 for( const art_effect_passive &i : effects ) {
11472 switch( i ) {
11473 case AEP_STR_UP:
11474 p.mod_str_bonus( +4 );
11475 break;
11476 case AEP_DEX_UP:
11477 p.mod_dex_bonus( +4 );
11478 break;
11479 case AEP_PER_UP:
11480 p.mod_per_bonus( +4 );
11481 break;
11482 case AEP_INT_UP:
11483 p.mod_int_bonus( +4 );
11484 break;
11485 case AEP_ALL_UP:
11486 p.mod_str_bonus( +2 );
11487 p.mod_dex_bonus( +2 );
11488 p.mod_per_bonus( +2 );
11489 p.mod_int_bonus( +2 );
11490 break;
11491 case AEP_SPEED_UP:
11492 // Handled in player::current_speed()
11493 break;
11494
11495 case AEP_PBLUE:
11496 if( p.get_rad() > 0 ) {
11497 p.mod_rad( -1 );
11498 }
11499 break;
11500
11501 case AEP_SMOKE:
11502 if( one_in( 10 ) ) {
11503 tripoint pt( p.posx() + rng( -1, 1 ),
11504 p.posy() + rng( -1, 1 ),
11505 p.posz() );
11506 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11507 }
11508 break;
11509
11510 case AEP_SNAKES:
11511 break; // Handled in player::hit()
11512
11513 case AEP_EXTINGUISH:
11514 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11515 m.mod_field_age( dest, fd_fire, -1_turns );
11516 }
11517 break;
11518
11519 case AEP_FUN:
11520 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11521 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11522 break;
11523
11524 case AEP_HUNGER:
11525 if( one_in( 100 ) ) {
11526 p.mod_stored_kcal( -10 );
11527 }
11528 break;
11529
11530 case AEP_THIRST:
11531 if( one_in( 120 ) ) {
11532 p.mod_thirst( 1 );
11533 }
11534 break;
11535
11536 case AEP_EVIL:
11537 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11538 p.add_effect( effect_evil, 30_minutes );
11539 if( it.is_armor() ) {
11540 if( !worn ) {
11541 add_msg( _( "You have an urge to wear the %s." ),
11542 it.tname() );
11543 }
11544 } else if( !wielded ) {
11545 add_msg( _( "You have an urge to wield the %s." ),
11546 it.tname() );
11547 }
11548 }
11549 break;
11550
11551 case AEP_SCHIZO:
11552 break; // Handled in player::suffer()
11553
11554 case AEP_RADIOACTIVE:
11555 if( one_in( 4 ) ) {
11556 p.irradiate( 1.0f );
11557 }
11558 break;
11559
11560 case AEP_STR_DOWN:
11561 p.mod_str_bonus( -3 );
11562 break;
11563
11564 case AEP_DEX_DOWN:
11565 p.mod_dex_bonus( -3 );
11566 break;
11567
11568 case AEP_PER_DOWN:
11569 p.mod_per_bonus( -3 );
11570 break;
11571
11572 case AEP_INT_DOWN:
11573 p.mod_int_bonus( -3 );
11574 break;
11575
11576 case AEP_ALL_DOWN:
11577 p.mod_str_bonus( -2 );
11578 p.mod_dex_bonus( -2 );
11579 p.mod_per_bonus( -2 );
11580 p.mod_int_bonus( -2 );
11581 break;
11582
11583 case AEP_SPEED_DOWN:
11584 break; // Handled in player::current_speed()
11585
11586 default:
11587 //Suppress warnings
11588 break;
11589 }
11590 }
11591 // Recalculate, as it might have changed (by mod_*_bonus above)
11592 p.str_cur = p.get_str();
11593 p.int_cur = p.get_int();
11594 p.dex_cur = p.get_dex();
11595 p.per_cur = p.get_per();
11596}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4184
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4179
int str_cur
Definition: character.h:247
void mod_rad(int mod)
Definition: character.cpp:7186
virtual int get_dex() const
Definition: character.cpp:4068
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4299
bool is_worn(const item &thing) const
Definition: character.h:1082
virtual int get_int() const
Definition: character.cpp:4076
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4430
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4174
int int_cur
Definition: character.h:249
int get_rad() const
Definition: character.cpp:7176
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9091
virtual int get_per() const
Definition: character.cpp:4072
void mod_stamina(int mod)
Definition: character.cpp:7213
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8657
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1529
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4189
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1352
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:4961
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7247
bool is_tool() const
Definition: item.cpp:6824
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7274
int charges
Definition: item.h:2195
bool is_armor() const
Definition: item.cpp:6575
const itype * type
Definition: item.h:2156
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5388
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5308
void remove_trap(const tripoint &p)
Definition: map.cpp:5253
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:866

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1711 of file game.cpp.

1712{
1713 if( u.has_effect( effect_sleep ) ) {
1714 // Can't interrupt
1715 return;
1716 }
1717
1718 bool has_activity = u.activity && u.activity.moves_left > 0;
1719 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1720
1721 if( !has_activity && !is_travelling ) {
1722 // Nohing to interrupt
1723 return;
1724 }
1725
1726 // Key poll may be quite expensive, so limit it to 10 times per second.
1727 static auto last_poll = std::chrono::steady_clock::now();
1728 auto now = std::chrono::steady_clock::now();
1729 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1730 ( now - last_poll ).count();
1731
1732 if( difference > 100 ) {
1734 last_poll = now;
1735 }
1736
1737 // If player is performing a task and a monster is dangerously close, warn them
1738 // regardless of previous safemode warnings
1739 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1741 Creature *hostile_critter = is_hostile_very_close();
1742 if( hostile_critter != nullptr ) {
1744 string_format( _( "The %s is dangerously close!" ),
1745 hostile_critter->get_name() ) );
1746 }
1747 }
1748}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9222
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2065
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8771 of file game.cpp.

8772{
8773 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8774
8775 if( !harmful_stuff.empty() &&
8776 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
8777 return false;
8778 }
8779 if( !harmful_stuff.empty() && u.is_mounted() &&
8780 m.tr_at( dest_loc ).loadid == tr_ledge ) {
8781 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
8782 u.mounted_creature->get_name() );
8783 return false;
8784 }
8785 return true;
8786}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11361 of file game.cpp.

11362{
11363 const WORLDPTR active_world = world_generator->active_world;
11364 if( active_world == nullptr ) {
11365 return;
11366 }
11367
11368 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11369 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11370 MAPBUFFER.reset();
11372 try {
11373 setup();
11374 } catch( const std::exception &err ) {
11375 debugmsg( "Error: %s", err.what() );
11376 }
11378 }
11379 } else {
11380 popup_getkey( _( "No saves for %s yet." ), u.name );
11381 }
11382}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2599
void setup()
Definition: game.cpp:568
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11339 of file game.cpp.

11340{
11341 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11342 if( !moves_since_last_save ) {
11343 return;
11344 }
11345 add_msg( m_info, _( "Saving game, this may take a while" ) );
11346
11348 popup.message( "%s", _( "Saving game, this may take a while" ) );
11351
11352 time_t now = time( nullptr ); //timestamp for start of saving procedure
11353
11354 //perform save
11355 save();
11356 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11358 last_save_timestamp = now;
11359}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 556 of file game.cpp.

557{
558 if( was_fullscreen ) {
559 if( !fullscreen ) {
561 }
562 }
563}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 968 of file game.cpp.

969{
970 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
971 // and not invoke "on_load" for those NPCs that avoided unloading this way.
972 unload_npcs();
973 load_npcs();
974}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 524 of file game.cpp.

525{
526#if defined(TILES)
527 try {
528 tilecontext->reinit();
529 std::vector<mod_id> dummy;
530 tilecontext->load_tileset(
531 get_option<std::string>( "TILES" ),
532 world_generator->active_world ? world_generator->active_world->active_mod_order : dummy,
533 false, true
534 );
535 tilecontext->do_tile_loading_report();
536 } catch( const std::exception &err ) {
537 popup( _( "Loading the tileset failed: %s" ), err.what() );
538 }
539 g->reset_zoom();
540 g->mark_main_ui_adaptor_resize();
541#endif // TILES
542}

References _, g, popup(), and world_generator.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2340 of file game.cpp.

2341{
2343 return remoteveh_cache;
2344 }
2346 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2347 if( remote_veh_string.str().empty() ||
2349 remoteveh_cache = nullptr;
2350 } else {
2351 tripoint vp;
2352 remote_veh_string >> vp.x >> vp.y >> vp.z;
2353 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2354 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2355 remoteveh_cache = veh;
2356 } else {
2357 remoteveh_cache = nullptr;
2358 }
2359 }
2360 return remoteveh_cache;
2361}
vehicle * remoteveh_cache
Definition: game.h:1066
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3359
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1974 of file game.cpp.

1975{
1976 follower_ids.erase( id );
1977 u.follower_ids.erase( id );
1978}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 4840 of file game.cpp.

4841{
4842 critter_tracker->remove( critter );
4843}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 10859 of file game.cpp.

10860{
10861 for( auto &elem : coming_to_stairs ) {
10862 elem.staircount = 0;
10863 const tripoint pnt( elem.pos().xy(), get_levz() );
10864 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
10865 }
10866
10867 coming_to_stairs.clear();
10868}
std::vector< monster > coming_to_stairs
Definition: game.h:1004

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7236 of file game.cpp.

7237{
7238 const int width = getmaxx( window );
7239 for( int i = 1; i < TERMX; i++ ) {
7240 if( i < width ) {
7241 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7242 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7243 LINE_OXOX ); // -
7244 }
7245
7246 if( i < TERMY - height ) {
7247 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7248 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7249 }
7250 }
7251
7252 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7253 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7254
7255 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7256 LINE_XXXO ); // |-
7257 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7258 LINE_XOXX ); // -|
7259
7260 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7261 wprintz( window, c_white, _( "Items" ) );
7262
7263 std::string sSort;
7264 if( bRadiusSort ) {
7265 //~ Sort type: distance.
7266 sSort = _( "<s>ort: dist" );
7267 } else {
7268 //~ Sort type: category.
7269 sSort = _( "<s>ort: cat" );
7270 }
7271
7272 int letters = utf8_width( sSort );
7273
7274 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7275
7276 std::vector<std::string> tokens;
7277 if( !sFilter.empty() ) {
7278 tokens.emplace_back( _( "<R>eset" ) );
7279 }
7280
7281 tokens.emplace_back( _( "<E>xamine" ) );
7282 tokens.emplace_back( _( "<C>ompare" ) );
7283 tokens.emplace_back( _( "<F>ilter" ) );
7284 tokens.emplace_back( _( "<+/->Priority" ) );
7285
7286 int gaps = tokens.size() + 1;
7287 letters = 0;
7288 int n = tokens.size();
7289 for( int i = 0; i < n; i++ ) {
7290 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7291 }
7292
7293 int usedwidth = letters;
7294 const int gap_spaces = ( width - usedwidth ) / gaps;
7295 usedwidth += gap_spaces * gaps;
7296 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7297
7298 for( int i = 0; i < n; i++ ) {
7299 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7300 tokens[i] ) + gap_spaces;
7301 }
7302}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3701 of file game.cpp.

3702{
3703 for( float &lev : latest_lightlevels ) {
3704 lev = -std::numeric_limits<float>::max();
3705 }
3706}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 2776 of file game.cpp.

2777{
2778 for( auto elem : follower_ids ) {
2779 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
2780 if( !npc_to_get ) {
2781 continue;
2782 }
2783 npc *npc_to_add = npc_to_get.get();
2784 npc_to_add->chatbin.missions.clear();
2785 npc_to_add->chatbin.missions_assigned.clear();
2786 npc_to_add->mission = NPC_MISSION_NULL;
2787 npc_to_add->chatbin.mission_selected = nullptr;
2788 npc_to_add->set_attitude( NPCATT_NULL );
2789 npc_to_add->op_of_u.anger = 0;
2790 npc_to_add->op_of_u.fear = 0;
2791 npc_to_add->op_of_u.trust = 0;
2792 npc_to_add->op_of_u.value = 0;
2793 npc_to_add->op_of_u.owed = 0;
2794 npc_to_add->set_fac( faction_id( "no_faction" ) );
2796 npc_to_add->global_omt_location(),
2797 npc_to_add->getID() ) );
2798
2799 }
2800
2801}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3144
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2640
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:466
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7151 of file game.cpp.

7152{
7153#if defined(TILES)
7155 rescale_tileset( tileset_zoom );
7156#endif // TILES
7157}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 4971 of file game.cpp.

4972{
4973 if( !it.is_corpse() ) {
4974 debugmsg( "Tried to revive a non-corpse." );
4975 return false;
4976 }
4977 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
4978 ( it.get_mtype()->id );
4979 monster &critter = *newmon_ptr;
4980 critter.init_from_item( it );
4981 if( critter.get_hp() < 1 ) {
4982 // Failed reanimation due to corpse being too burned
4983 return false;
4984 }
4985 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
4986 it.has_flag( "QUARTERED" ) ) {
4987 // Failed reanimation due to corpse being butchered
4988 return false;
4989 }
4990
4991 critter.no_extra_death_drops = true;
4992 critter.add_effect( effect_downed, 5_turns, num_bp );
4993 for( const item &component : it.components ) {
4994 critter.corpse_components.push_back( component );
4995 }
4996
4997 if( it.get_var( "zlave" ) == "zlave" ) {
4998 critter.add_effect( effect_pacified, 1_turns, num_bp );
4999 critter.add_effect( effect_pet, 1_turns, num_bp );
5000 }
5001
5002 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
5003 for( auto &ammo : critter.ammo ) {
5004 ammo.second = 0;
5005 }
5006 }
5007
5008 return place_critter_at( newmon_ptr, p );
5009}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4768
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1025
const mtype * get_mtype() const
Definition: item.cpp:6496
std::list< item > components
Definition: item.h:2158
bool has_flag(const std::string &flag) const
Definition: item.cpp:5213
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6491
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2919
bool no_extra_death_drops
Definition: monster.h:483
std::vector< item > corpse_components
Definition: monster.h:460
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2783
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 2877 of file game.cpp.

2878{
2879 try {
2880 if( !save_player_data() ||
2882 !save_artifacts() ||
2883 !save_maps() ||
2884 !get_auto_pickup().save_character() ||
2886 !get_safemode().save_character() ||
2887 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
2888 JsonOut jsout( fout );
2889 uistate.serialize( jsout );
2890 }, _( "uistate data" ) ) ) {
2891 return false;
2892 } else {
2893 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
2894 return true;
2895 }
2896 } catch( std::ios::failure &err ) {
2897 popup( _( "Failed to save game data" ) );
2898 return false;
2899 }
2900}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:2831
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 2812 of file game.cpp.

2813{
2814 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
2815 return ::save_artifacts( artfilename );
2816}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5011 of file game.cpp.

5012{
5013 int assist_bonus = installer.get_effect_int( effect_assisted );
5014
5015 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
5018 -1 );
5019
5020 int damage = cyborg->damage();
5021 int dmg_lvl = cyborg->damage_level( 4 );
5022 int difficulty = 12;
5023
5024 if( damage != 0 ) {
5025
5026 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
5027 dmg_lvl );
5028
5029 // Damage of the cyborg increases difficulty
5030 difficulty += dmg_lvl;
5031 }
5032
5033 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
5034 int success = chance_of_success - rng( 1, 100 );
5035
5036 if( !g->u.query_yn(
5037 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5038 100 - static_cast<int>( chance_of_success ) ) ) {
5039 return;
5040 }
5041
5042 if( success > 0 ) {
5043 add_msg( m_good, _( "Successfully removed Personality override." ) );
5044 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5045
5046 m.i_rem( couch_pos, cyborg );
5047
5048 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5049 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5050 tmp->normalize();
5051 tmp->load_npc_template( npc_cyborg );
5052 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5054 tmp->hurtall( dmg_lvl * 10, nullptr );
5055 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5056 load_npcs();
5057
5058 } else {
5059 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5060 adjusted_skill ) );
5061 const int fail_type = std::min( 5, failure_level );
5062 switch( fail_type ) {
5063 case 1:
5064 case 2:
5065 add_msg( m_info, _( "The removal fails." ) );
5066 add_msg( m_bad, _( "The body is damaged." ) );
5067 cyborg->set_damage( damage + 1000 );
5068 break;
5069 case 3:
5070 case 4:
5071 add_msg( m_info, _( "The removal fails badly." ) );
5072 add_msg( m_bad, _( "The body is badly damaged!" ) );
5073 cyborg->set_damage( damage + 2000 );
5074 break;
5075 case 5:
5076 add_msg( m_info, _( "The removal is a catastrophe." ) );
5077 add_msg( m_bad, _( "The body is destroyed!" ) );
5078 m.i_rem( couch_pos, cyborg );
5079 break;
5080 default:
5081 break;
5082 }
5083
5084 }
5085
5086}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1886
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1843
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:714
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:701
int damage() const
How much damage has the item sustained?
Definition: item.cpp:696
map_stack::iterator i_rem(const tripoint &p, map_stack::const_iterator it)
Definition: map.cpp:4084
static const skill_id skill_computer("computer")
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 2804 of file game.cpp.

2805{
2806 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
2807 return write_to_file( masterfile, [&]( std::ostream & fout ) {
2808 serialize_master( fout );
2809 }, _( "factions data" ) );
2810}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1238

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 2818 of file game.cpp.

2819{
2820 try {
2821 m.save();
2822 overmap_buffer.save(); // can throw
2823 MAPBUFFER.save(); // can throw
2824 return true;
2825 } catch( const std::exception &err ) {
2826 popup( _( "Failed to save the maps: %s" ), err.what() );
2827 return false;
2828 }
2829}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 2831 of file game.cpp.

2832{
2833 const std::string playerfile = get_player_base_save_path();
2834
2835 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
2836 serialize( fout );
2837 }, _( "player data" ) );
2838 const bool saved_map_memory = u.save_map_memory();
2839 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
2840 std::ostream & fout ) {
2841 fout << memorial().dump();
2842 }, _( "player memorial" ) );
2843#if defined(__ANDROID__)
2844 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
2845 std::ostream & fout ) {
2846 save_shortcuts( fout );
2847 }, _( "quick shortcuts" ) );
2848#endif
2849
2850 return saved_data && saved_map_memory && saved_log
2851#if defined(__ANDROID__)
2852 && saved_shortcuts
2853#endif
2854 ;
2855}
bool save_map_memory()
Definition: avatar.cpp:129
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12076
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:996
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1238 of file savegame.cpp.

1239{
1240 fout << "# version " << savegame_version << std::endl;
1241 try {
1242 JsonOut json( fout, true ); // pretty-print
1243 json.start_object();
1244
1245 json.member( "next_mission_id", next_mission_id );
1246 json.member( "next_npc_id", next_npc_id );
1247
1248 json.member( "active_missions" );
1249 mission::serialize_all( json );
1250
1251 json.member( "factions", *faction_manager_ptr );
1252 json.member( "seed", seed );
1253
1254 json.member( "weather" );
1255 json.start_object();
1256 json.member( "lightning", get_weather().lightning_active );
1257 json.end_object();
1258
1259 json.end_object();
1260 } catch( const JsonError &e ) {
1261 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1262 }
1263}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1229

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1882 of file game.cpp.

1883{
1884 critter_died = true;
1885}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1699 of file game.cpp.

1700{
1701 // remove the previous driving offset,
1702 // store the new offset and apply the new offset.
1709}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1877 of file game.cpp.

1878{
1879 npcs_dirty = true;
1880}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 8698 of file game.cpp.

8699{
8700 safe_mode = mode;
8702}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7159 of file game.cpp.

7160{
7161#if defined(TILES)
7162 if( tileset_zoom != level ) {
7163 tileset_zoom = level;
7164 rescale_tileset( tileset_zoom );
7165 }
7166#else
7167 static_cast<void>( level );
7168#endif // TILES
7169}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2363 of file game.cpp.

2364{
2366 remoteveh_cache = veh;
2367 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2369 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2370 veh = nullptr;
2371 }
2372
2373 if( veh == nullptr ) {
2374 u.remove_value( "remote_controlling_vehicle" );
2375 return;
2376 }
2377
2378 std::stringstream remote_veh_string;
2379 const tripoint vehpos = veh->global_pos3();
2380 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2381 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2382}
void remove_value(const std::string &key)
Definition: creature.cpp:1336

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 568 of file game.cpp.

569{
570 loading_ui ui( true );
571 {
574 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
577
579 }
580
582
583 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
584 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
585 }
586
587 m = map( get_option<bool>( "ZLEVELS" ) );
588
590 next_mission_id = 1;
591 new_game = true;
592 uquit = QUIT_NO; // We haven't quit the game
593 bVMonsterLookFire = true;
594
595 // invalidate calendar caches in case we were previously playing
596 // a different world
597 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
598 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
599
602
603 turnssincelastmon = 0; //Auto safe mode init
604
607 coming_to_stairs.clear();
608 active_npc.clear();
609 faction_manager_ptr->clear();
614
615 SCT.vSCT.clear(); //Delete pending messages
616
617 stats().clear();
618 // reset kill counts
619 kill_tracker_ptr->clear();
621 // reset follower list
622 follower_ids.clear();
623 scent.reset();
624
626 remoteveh_cache = nullptr;
627
628 token_provider_ptr->clear();
629 // back to menu for save loading, new game etc
630}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:4845
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2711
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4698 of file game.cpp.

4699{
4700 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4701 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4702 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4703 }
4704 if( critter.is_monster() ) {
4705 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4706 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4707 return std::dynamic_pointer_cast<T>( mon_ptr );
4708 }
4709 }
4710 }
4711 if( critter.is_npc() ) {
4712 for( auto &cur_npc : active_npc ) {
4713 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4714 return std::dynamic_pointer_cast<T>( cur_npc );
4715 }
4716 }
4717 }
4718 return nullptr;
4719}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12089 of file game.cpp.

12090{
12091 for( tripoint &p : destination_preview ) {
12092 p += delta;
12093 }
12094}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11094 of file game.cpp.

11095{
11096 // If either shift argument is non-zero, we're shifting.
11097 if( shift == tripoint_zero ) {
11098 return;
11099 }
11100 for( monster &critter : all_monsters() ) {
11101 if( shift.xy() != point_zero ) {
11102 critter.shift( shift.xy() );
11103 }
11104
11105 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11106 // We're inbounds, so don't despawn after all.
11107 // No need to shift Z-coordinates, they are absolute
11108 continue;
11109 }
11110 // Either a vertical shift or the critter is now outside of the reality bubble,
11111 // anyway: it must be saved and removed.
11112 despawn_monster( critter );
11113 }
11114 // The order in which zombies are shifted may cause zombies to briefly exist on
11115 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11116 critter_tracker->rebuild_cache();
11117}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12096 of file game.cpp.

12097{
12098 ///\EFFECT_DEX decreases chances of slipping while climbing
12099 int climb = u.dex_cur;
12100 if( u.has_trait( trait_BADKNEES ) ) {
12101 climb = climb / 2;
12102 }
12103 if( one_in( climb ) ) {
12104 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12105 if( climb <= 1 ) {
12106 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12107 }
12108 return true;
12109 }
12110 return false;
12111}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 4856 of file game.cpp.

4857{
4858 if( one_in( 100 ) ) {
4859 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4860 tmp->normalize();
4861 tmp->randomize( NC_HALLU );
4862 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
4863 if( !critter_at( p, true ) ) {
4865 load_npcs();
4866 return true;
4867 } else {
4868 return false;
4869 }
4870 }
4871
4873 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
4874 phantasm->hallucination = true;
4875 phantasm->spawn( p );
4876
4877 //Don't attempt to place phantasms inside of other creatures
4878 if( !critter_at( phantasm->pos(), true ) ) {
4879 return critter_tracker->add( phantasm );
4880 } else {
4881 return false;
4882 }
4883}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 2872 of file game.cpp.

2873{
2874 return *spell_events_ptr;
2875}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 11658 of file game.cpp.

11659{
11660 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
11661 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
11662 scen->has_flag( "SUM_ADV_START" );
11663
11665 if( scen_season ) {
11666 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
11668 get_option<int>( "INITIAL_TIME" );
11669 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
11670 if( scen->has_flag( "SPR_START" ) ) {
11672 } else if( scen->has_flag( "SUM_START" ) ) {
11675 } else if( scen->has_flag( "AUT_START" ) ) {
11678 } else if( scen->has_flag( "WIN_START" ) ) {
11681 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
11684 } else {
11685 debugmsg( "The Unicorn" );
11686 }
11687 } else {
11688 // No scenario, so use the starting date+time configured in world options
11689 int initial_days = get_option<int>( "INITIAL_DAY" );
11690 if( initial_days == -1 ) {
11691 // 0 - 363 for a 91 day season
11692 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
11693 }
11695
11696 // Determine the season based off how long the seasons are set to be
11697 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
11698 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
11699 if( season_number == 0 ) {
11701 } else if( season_number == 1 ) {
11703 } else if( season_number == 2 ) {
11705 } else {
11707 }
11708
11710 + 1_hours * get_option<int>( "INITIAL_TIME" )
11711 + 1_days * get_option<int>( "SPAWN_DELAY" );
11712 }
11713
11715}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1003
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 655 of file game.cpp.

656{
657 if( !gamemode ) {
658 gamemode = std::make_unique<special_game>();
659 }
660
661 seed = rng_bits();
662 new_game = true;
665 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
666 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
668
670
673 popup.message( "%s", _( "Please wait as we build your world" ) );
676
677 load_master();
678 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
679
683 do {
684 omtstart = start_loc.find_player_initial_location();
685 if( omtstart == overmap::invalid_tripoint ) {
686 if( query_yn(
687 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
690 } else {
691 return false;
692 }
693 }
694 } while( omtstart == overmap::invalid_tripoint );
695
696 start_loc.prepare_map( omtstart );
697
698 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
699 if( u.starting_vehicle &&
700 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
701 std::vector<std::string> {} ) ) {
702 debugmsg( "could not place starting vehicle" );
703 }
704
705 if( scen->has_map_extra() ) {
706 // Map extras can add monster spawn points and similar and should be done before the main
707 // map is loaded.
708 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
709 }
710
711 // TODO: fix point types
712 tripoint lev = project_to<coords::sm>( omtstart ).raw();
713 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
714 lev.x -= HALF_MAPSIZE;
715 lev.y -= HALF_MAPSIZE;
716 load_map( lev );
717
720 // Do this after the map cache has been built!
721 start_loc.place_player( u );
722 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
725 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
727 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
728
729 u.moves = 0;
730 u.process_turn(); // process_turn adds the initial move points
734 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
736
737 //Reset character safe mode/pickup rules
742
743 //Put some NPCs in there!
744 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
745 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
746 !g->scen->has_flag( "LONE_START" ) ) ) {
748 }
749 //Load NPCs. Set nearby npcs to active.
750 load_npcs();
751 // Spawn the monsters
752 const bool spawn_near =
753 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
754 // Surrounded start ones
755 if( spawn_near ) {
756 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
757 }
758
759 m.spawn_monsters( !spawn_near ); // Static monsters
760
761 // Make sure that no monsters are near the player
762 // This can happen in lab starts
763 if( !spawn_near ) {
764 for( monster &critter : all_monsters() ) {
765 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
766 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
767 remove_zombie( critter );
768 }
769 }
770 }
771
772 //Create mutation_category_level
774 //Calculate mutation drench protection stats
777 if( scen->has_flag( "FIRE_START" ) ) {
778 start_loc.burn( omtstart, 3, 3 );
779 }
780 if( scen->has_flag( "INFECTED" ) ) {
782 }
783 if( scen->has_flag( "BAD_DAY" ) ) {
784 u.add_effect( effect_flu, 1000_minutes );
785 u.add_effect( effect_drunk, 270_minutes );
786 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
787 }
788 if( scen->has_flag( "HELI_CRASH" ) ) {
789 start_loc.handle_heli_crash( u );
790 bool success = false;
791 for( auto v : m.get_vehicles() ) {
792 std::string name = v.v->type.str();
793 std::string search = std::string( "helicopter" );
794 if( name.find( search ) != std::string::npos ) {
795 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
796 const tripoint pos = vp.pos();
797 u.setpos( pos );
798
799 // Delete the items that would have spawned here from a "corpse"
800 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
801 vehicle_stack here = v.v->get_items( sp );
802
803 for( auto iter = here.begin(); iter != here.end(); ) {
804 iter = here.erase( iter );
805 }
806 }
807
808 auto mons = critter_tracker->find( pos );
809 if( mons != nullptr ) {
810 critter_tracker->remove( *mons );
811 }
812
813 success = true;
814 break;
815 }
816 if( success ) {
817 v.v->name = "Bird Wreckage";
818 break;
819 }
820 }
821 }
822 }
823 if( scen->has_flag( "BORDERED" ) ) {
824 overmap &starting_om = get_cur_om();
825 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
826 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
828 }
829
830 }
831 for( auto &e : u.inv_dump() ) {
832 e->set_owner( g->u );
833 }
834 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
835 update_map( u );
836 // Profession pets
837 for( const mtype_id &elem : u.starting_pets ) {
838 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
839 mon->friendly = -1;
840 mon->add_effect( effect_pet, 1_turns, num_bp );
841 } else {
842 add_msg( m_debug, "cannot place starting pet, no space!" );
843 }
844 }
845 // Assign all of this scenario's missions to the player.
846 for( const mission_type_id &m : scen->missions() ) {
847 const auto mission = mission::reserve_new( m, character_id() );
848 mission->assign( u );
849 }
850
851 g->events().send<event_type::game_start>( u.getID() );
852 return true;
853}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2215
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7946
void set_stamina(int new_stamina)
Definition: character.cpp:7208
time_point next_climate_control_check
Definition: character.h:2214
int get_stamina_max() const
Definition: character.cpp:7199
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7923
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:11658
void create_starting_npcs()
Definition: game.cpp:981
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:11956
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:855
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6386
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2163
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:592
vproto_id starting_vehicle
Definition: player.h:604
std::vector< mtype_id > starting_pets
Definition: player.h:605
start_location_id start_location
Definition: player.h:593
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:134
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:105
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10457 of file game.cpp.

10458{
10459 // Find target items and quantities thereof for the new activity
10460 std::vector<item_location> target_items;
10461 std::vector<int> quantities;
10462
10463 map_stack items = m.i_at( pos );
10464 for( item &it : items ) {
10465 // Liquid cannot be picked up
10466 if( it.made_of( LIQUID ) ) {
10467 continue;
10468 }
10469 target_items.emplace_back( map_cursor( pos ), &it );
10470 // Quantity of 0 means move all
10471 quantities.push_back( 0 );
10472 }
10473
10474 if( target_items.empty() ) {
10475 // Nothing to haul
10476 return;
10477 }
10478
10479 // Whether the destination is inside a vehicle (not supported)
10480 const bool to_vehicle = false;
10481 // Destination relative to the player
10482 const tripoint relative_destination{};
10483
10485 target_items,
10486 quantities,
10487 to_vehicle,
10488 relative_destination
10489 ) ) );
10490}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 2862 of file game.cpp.

2863{
2864 return *stats_tracker_ptr;
2865}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 4885 of file game.cpp.

4886{
4887 if( &a == &b ) {
4888 // No need to do anything, but print a debugmsg anyway
4889 debugmsg( "Tried to swap %s with itself", a.disp_name() );
4890 return true;
4891 }
4892 if( critter_at( a.pos() ) != &a ) {
4893 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4894 b.disp_name(), critter_at( a.pos() )->disp_name() );
4895 return false;
4896 }
4897 if( critter_at( b.pos() ) != &b ) {
4898 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4899 a.disp_name(), critter_at( b.pos() )->disp_name() );
4900 return false;
4901 }
4902 // Simplify by "sorting" the arguments
4903 // Only the first argument can be u
4904 // If swapping player/npc with a monster, monster is second
4905 bool a_first = a.is_player() ||
4906 ( a.is_npc() && !b.is_player() );
4907 Creature &first = a_first ? a : b;
4908 Creature &second = a_first ? b : a;
4909 // Possible options:
4910 // both first and second are monsters
4911 // second is a monster, first is a player or an npc
4912 // first is a player, second is an npc
4913 // both first and second are npcs
4914 if( first.is_monster() ) {
4915 monster *m1 = dynamic_cast< monster * >( &first );
4916 monster *m2 = dynamic_cast< monster * >( &second );
4917 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
4918 debugmsg( "Couldn't swap two monsters" );
4919 return false;
4920 }
4921
4922 critter_tracker->swap_positions( *m1, *m2 );
4923 return true;
4924 }
4925
4926 player *u_or_npc = dynamic_cast< player * >( &first );
4927 player *other_npc = dynamic_cast< player * >( &second );
4928
4929 if( u_or_npc->in_vehicle ) {
4930 m.unboard_vehicle( u_or_npc->pos() );
4931 }
4932
4933 if( other_npc && other_npc->in_vehicle ) {
4934 m.unboard_vehicle( other_npc->pos() );
4935 }
4936
4937 tripoint temp = second.pos();
4938 second.setpos( first.pos() );
4939
4940 if( first.is_player() ) {
4941 walk_move( temp );
4942 } else {
4943 first.setpos( temp );
4944 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4945 m.board_vehicle( u_or_npc->pos(), u_or_npc );
4946 }
4947 }
4948
4949 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4950 m.board_vehicle( other_npc->pos(), other_npc );
4951 }
4952 return true;
4953}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:8837
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7228 of file game.cpp.

7229{
7230 popup( _( "This binary was not compiled with tiles support." ) );
7231 return false;
7232}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7222 of file game.cpp.

7223{
7224 popup( _( "This binary was not compiled with tiles support." ) );
7225 return false;
7226}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 546 of file game.cpp.

547{
548 if( fullscreen ) {
549 was_fullscreen = true;
551 } else {
552 was_fullscreen = false;
553 }
554}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11265 of file game.cpp.

11266{
11268}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 503 of file game.cpp.

504{
505#if !defined(TILES)
508#else
509 toggle_fullscreen_window();
510#endif
511}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 513 of file game.cpp.

514{
515#if defined(TILES)
517 clear_window_area( w_pixel_minimap );
518 }
521#endif // TILES
522}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2384 of file game.cpp.

2385{
2386 bool new_destination = true;
2387 if( !destination_preview.empty() ) {
2388 auto &final_destination = destination_preview.back();
2389 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2390 // Second click
2391 new_destination = false;
2393 destination_preview.clear();
2395 if( act == ACTION_NULL ) {
2396 // Something went wrong
2398 return false;
2399 }
2400 }
2401 }
2402
2403 if( new_destination ) {
2405 u.get_path_avoid() );
2406 return false;
2407 }
2408
2409 return true;
2410}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2412 of file game.cpp.

2413{
2414 const bool cleared_destination = !destination_preview.empty();
2416 destination_preview.clear();
2417
2418 if( cleared_destination ) {
2419 // Produce no-op if auto-move had just been cleared on this action
2420 // e.g. from a previous single left mouse click. This has the effect
2421 // of right-click canceling an auto-move before it is initiated.
2422 return false;
2423 }
2424
2425 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2426 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2427 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2428 if( !u.sees( *mon ) ) {
2429 add_msg( _( "Nothing relevant here." ) );
2430 return false;
2431 }
2432
2433 if( !u.weapon.is_gun() ) {
2434 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2435 return false;
2436 }
2437
2438 // TODO: Add weapon range check. This requires weapon to be reloaded.
2439
2440 act = ACTION_FIRE;
2441 } else if( is_adjacent &&
2442 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2443 true ) ) {
2444 act = ACTION_CLOSE;
2445 } else if( is_self ) {
2447 } else if( is_adjacent ) {
2449 } else {
2450 add_msg( _( "Nothing relevant here." ) );
2451 return false;
2452 }
2453
2454 return true;
2455}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3955
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 959 of file game.cpp.

960{
961 for( const auto &npc : active_npc ) {
962 npc->on_unload();
963 }
964
965 active_npc.clear();
966}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2645

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map( tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ) );
207
208 safe_mode = static_cast<safe_mode_type>( tmprun );
209 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
211 }
212
213 std::string linebuff;
214 std::string linebuf;
215 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
216 scent.deserialize( linebuf );
217 scent.deserialize( linebuff, true );
218 } else {
219 scent.reset();
220 }
221 data.read( "active_monsters", *critter_tracker );
222
223 coming_to_stairs.clear();
224 for( auto elem : data.get_array( "stair_monsters" ) ) {
225 monster stairtmp;
226 elem.read( stairtmp );
227 coming_to_stairs.push_back( stairtmp );
228 }
229
230 if( data.has_object( "kill_tracker" ) ) {
231 data.read( "kill_tracker", *kill_tracker_ptr );
232 } else {
233 // Legacy support for when kills were stored directly in game
234 std::map<mtype_id, int> kills;
235 std::vector<std::string> npc_kills;
236 for( const JsonMember member : data.get_object( "kills" ) ) {
237 kills[mtype_id( member.name() )] = member.get_int();
238 }
239
240 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
241 npc_kills.push_back( npc_name );
242 }
243
244 kill_tracker_ptr->reset( kills, npc_kills );
245 }
246
247 data.read( "player", u );
248 data.read( "stats_tracker", *stats_tracker_ptr );
249 data.read( "achievements_tracker", *achievements_tracker_ptr );
250 data.read( "token_provider", token_provider_ptr );
251 Messages::deserialize( data );
252
253 } catch( const JsonError &jsonerr ) {
254 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
255 return;
256 }
257}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:259
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:402
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1188 of file savegame.cpp.

1189{
1191 chkversion( fin );
1192 if( savegame_loading_version < 11 ) {
1193 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1194 popup->message(
1195 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1199 }
1200 try {
1201 // single-pass parsing example
1202 JsonIn jsin( fin );
1203 jsin.start_object();
1204 while( !jsin.end_object() ) {
1205 std::string name = jsin.get_member_name();
1206 if( name == "next_mission_id" ) {
1207 next_mission_id = jsin.get_int();
1208 } else if( name == "next_npc_id" ) {
1209 next_npc_id.deserialize( jsin );
1210 } else if( name == "active_missions" ) {
1212 } else if( name == "factions" ) {
1213 jsin.read( *faction_manager_ptr );
1214 } else if( name == "seed" ) {
1215 jsin.read( seed );
1216 } else if( name == "weather" ) {
1217 JsonObject w = jsin.get_object();
1218 w.read( "lightning", get_weather().lightning_active );
1219 } else {
1220 // silently ignore anything else
1221 jsin.skip_value();
1222 }
1223 }
1224 } catch( const JsonError &e ) {
1225 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1226 }
1227}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1178

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 10725 of file game.cpp.

10726{
10727 point shift;
10728
10729 while( x < HALF_MAPSIZE_X ) {
10730 x += SEEX;
10731 shift.x--;
10732 }
10733 while( x >= HALF_MAPSIZE_X + SEEX ) {
10734 x -= SEEX;
10735 shift.x++;
10736 }
10737 while( y < HALF_MAPSIZE_Y ) {
10738 y += SEEY;
10739 shift.y--;
10740 }
10741 while( y >= HALF_MAPSIZE_Y + SEEY ) {
10742 y -= SEEY;
10743 shift.y++;
10744 }
10745
10746 if( shift == point_zero ) {
10747 // adjust player position
10748 u.setpos( tripoint( x, y, get_levz() ) );
10749 // Update what parts of the world map we can see
10750 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
10751 // TODO: only make this call if we changed z-level
10753 // Not actually shifting the submaps, all the stuff below would do nothing
10754 return point_zero;
10755 }
10756
10757 // this handles loading/unloading submaps that have scrolled on or off the viewport
10758 // NOLINTNEXTLINE(cata-use-named-point-constants)
10759 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
10760 point remaining_shift = shift;
10761 while( remaining_shift != point_zero ) {
10762 point this_shift = clamp( remaining_shift, size_1 );
10763 m.shift( this_shift );
10764 remaining_shift -= this_shift;
10765 }
10766
10767 grid_tracker_ptr->load( m );
10768
10769 // Shift monsters
10770 shift_monsters( tripoint( shift, 0 ) );
10771 const point shift_ms = sm_to_ms_copy( shift );
10772 u.shift_destination( -shift_ms );
10773
10774 // Shift NPCs
10775 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
10776 ( *it )->shift( shift );
10777 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
10778 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
10779 //Remove the npc from the active list. It remains in the overmap list.
10780 ( *it )->on_unload();
10781 it = active_npc.erase( it );
10782 } else {
10783 it++;
10784 }
10785 }
10786
10787 scent.shift( shift_ms );
10788
10789 // Also ensure the player is on current z-level
10790 // get_levz() should later be removed, when there is no longer such a thing
10791 // as "current z-level"
10792 u.setpos( tripoint( x, y, get_levz() ) );
10793
10794 // Only do the loading after all coordinates have been shifted.
10795
10796 // Check for overmap saved npcs that should now come into view.
10797 // Put those in the active list.
10798 load_npcs();
10799
10800 // Make sure map cache is consistent since it may have shifted.
10801 if( m.has_zlevels() ) {
10802 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
10803 m.invalidate_map_cache( zlev );
10804 }
10805 } else {
10807 }
10809
10810 // Spawn monsters if appropriate
10811 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
10812 m.spawn_monsters( false ); // Static monsters
10813
10814 // Update what parts of the world map we can see
10816
10817 return shift;
10818}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11094
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6755
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 10719 of file game.cpp.

10720{
10721 point p2( p.posx(), p.posy() );
10722 return update_map( p2.x, p2.y );
10723}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 10820 of file game.cpp.

10821{
10822 const tripoint_abs_omt ompos = u.global_omt_location();
10823 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
10824 const int dist_squared = dist * dist;
10825 // We can always see where we're standing
10826 overmap_buffer.set_seen( ompos, true );
10827 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
10828 const point_rel_omt delta = p.xy() - ompos.xy();
10829 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
10830 if( trigdist && h_squared > dist_squared ) {
10831 continue;
10832 }
10833 if( delta == point_rel_omt() ) {
10834 // 1. This case is already handled outside of the loop
10835 // 2. Calculating multiplier would cause division by zero
10836 continue;
10837 }
10838 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
10839 point abs_delta = delta.raw().abs();
10840 int max_delta = std::max( abs_delta.x, abs_delta.y );
10841 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
10842 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
10843 float sight_points = dist;
10844 for( auto it = line.begin();
10845 it != line.end() && sight_points >= 0; ++it ) {
10846 const oter_id &ter = overmap_buffer.ter( *it );
10847 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
10848 }
10849 if( sight_points >= 0 ) {
10850 tripoint_abs_omt seen( p );
10851 do {
10852 overmap_buffer.set_seen( seen, true );
10853 --seen.z();
10854 } while( seen.z() >= 0 );
10855 }
10856 }
10857}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:771
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 10872 of file game.cpp.

10873{
10874 // Search for the stairs closest to the player.
10875 std::vector<int> stairx;
10876 std::vector<int> stairy;
10877 std::vector<int> stairdist;
10878
10879 const bool from_below = monstairz < get_levz();
10880
10881 if( coming_to_stairs.empty() ) {
10882 return;
10883 }
10884
10885 if( m.has_zlevels() ) {
10886 debugmsg( "%d monsters coming to stairs on a map with z-levels",
10887 coming_to_stairs.size() );
10888 coming_to_stairs.clear();
10889 }
10890
10891 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
10892 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
10893 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
10894 stairx.push_back( dest.x );
10895 stairy.push_back( dest.y );
10896 stairdist.push_back( rl_dist( dest, u.pos() ) );
10897 }
10898 }
10899 if( stairdist.empty() ) {
10900 return; // Found no stairs?
10901 }
10902
10903 // Find closest stairs.
10904 size_t si = 0;
10905 for( size_t i = 0; i < stairdist.size(); i++ ) {
10906 if( stairdist[i] < stairdist[si] ) {
10907 si = i;
10908 }
10909 }
10910
10911 // Find up to 4 stairs for distance stairdist[si] +1
10912 std::vector<int> nearest;
10913 nearest.push_back( si );
10914 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
10915 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
10916 nearest.push_back( i );
10917 }
10918 }
10919 // Randomize the stair choice
10920 si = random_entry_ref( nearest );
10921
10922 // Attempt to spawn zombies.
10923 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
10924 point mpos( stairx[si], stairy[si] );
10925 monster &critter = coming_to_stairs[i];
10926 const tripoint dest {
10927 mpos, g->get_levz()
10928 };
10929
10930 // We might be not be visible.
10931 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
10932 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
10933 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
10934 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
10935 continue;
10936 }
10937
10938 critter.staircount -= 4;
10939 // Let the player know zombies are trying to come.
10940 if( u.sees( dest ) ) {
10941 std::string dump;
10942 if( critter.staircount > 4 ) {
10943 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
10944 } else {
10945 if( critter.staircount > 0 ) {
10946 dump += ( from_below ?
10947 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
10948 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
10949 critter.name(),
10950 m.tername( dest ) ) :
10951 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
10952 critter.name(),
10953 m.tername( dest ) ) );
10954 }
10955 }
10956
10957 add_msg( m_warning, dump );
10958 } else {
10960 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
10961 }
10962
10963 if( critter.staircount > 0 ) {
10964 continue;
10965 }
10966
10967 if( is_empty( dest ) ) {
10968 critter.spawn( dest );
10969 critter.staircount = 0;
10970 place_critter_at( make_shared_fast<monster>( critter ), dest );
10971 if( u.sees( dest ) ) {
10972 if( !from_below ) {
10973 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
10974 critter.name(),
10975 m.tername( dest ) );
10976 } else {
10977 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
10978 critter.name(),
10979 m.tername( dest ) );
10980 }
10981 }
10982 coming_to_stairs.erase( coming_to_stairs.begin() + i );
10983 continue;
10984 } else if( u.pos() == dest ) {
10985 // Monster attempts to push player of stairs
10987 int tries = 0;
10988
10989 // the critter is now right on top of you and will attack unless
10990 // it can find a square to push you into with one of his tries.
10991 const int creature_push_attempts = 9;
10992 const int player_throw_resist_chance = 3;
10993
10994 critter.spawn( dest );
10995 while( tries < creature_push_attempts ) {
10996 tries++;
10997 push.x = rng( -1, 1 );
10998 push.y = rng( -1, 1 );
10999 point ipos( mpos + push );
11000 tripoint pos( ipos, get_levz() );
11001 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
11002 critter.can_move_to( pos ) ) {
11003 bool resiststhrow = ( u.is_throw_immune() ) ||
11005 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
11006 u.moves -= 25; // small charge for avoiding the push altogether
11007 add_msg( _( "The %s fails to push you back!" ),
11008 critter.name() );
11009 return; //judo or leg brace prevent you from getting pushed at all
11010 }
11011 // Not accounting for tentacles latching on, so..
11012 // Something is about to happen, lets charge half a move
11013 u.moves -= 50;
11014 if( resiststhrow && ( u.is_throw_immune() ) ) {
11015 //we have a judoka who isn't getting pushed but counterattacking now.
11016 mattack::thrown_by_judo( &critter );
11017 return;
11018 }
11019 std::string msg;
11020 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
11021 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
11022 // dodge 12 - never get downed
11023 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
11024 u.add_effect( effect_downed, 2_turns );
11025 msg = _( "The %s pushed you back hard!" );
11026 } else {
11027 msg = _( "The %s pushed you back!" );
11028 }
11029 add_msg( m_warning, msg.c_str(), critter.name() );
11030 u.setx( u.posx() + push.x );
11031 u.sety( u.posy() + push.y );
11032 return;
11033 }
11034 }
11036 _( "The %s tried to push you back but failed! It attacks you!" ),
11037 critter.name() );
11038 critter.melee_attack( u );
11039 u.moves -= 50;
11040 return;
11041 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11042 // Monster attempts to displace a monster from the stairs
11043 monster &other = *mon_ptr;
11044 critter.spawn( dest );
11045
11046 // the critter is now right on top of another and will push it
11047 // if it can find a square to push it into inside of his tries.
11048 const int creature_push_attempts = 9;
11049 const int creature_throw_resist = 4;
11050
11051 int tries = 0;
11052 point push2;
11053 while( tries < creature_push_attempts ) {
11054 tries++;
11055 push2.x = rng( -1, 1 );
11056 push2.y = rng( -1, 1 );
11057 point ipos2( mpos + push2 );
11058 tripoint pos( ipos2, get_levz() );
11059 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11060 continue;
11061 }
11062 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11063 other.setpos( tripoint( ipos2, get_levz() ) );
11064 other.moves -= 50;
11065 std::string msg;
11066 if( one_in( creature_throw_resist ) ) {
11067 other.add_effect( effect_downed, 2_turns );
11068 msg = _( "The %1$s pushed the %2$s hard." );
11069 } else {
11070 msg = _( "The %1$s pushed the %2$s." );
11071 }
11072 add_msg( m_neutral, msg, critter.name(), other.name() );
11073 return;
11074 }
11075 }
11076 return;
11077 }
11078 }
11079}
void setx(int x)
Definition: character.h:788
void sety(int y)
Definition: character.h:791
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:811
int monstairz
Definition: game.h:1005
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8614
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:258
int posy() const override
Definition: monster.h:501
void melee_attack(Creature &target)
Definition: monster.cpp:1390
int staircount
Definition: monster.h:512
void spawn(const tripoint &p)
Definition: monster.cpp:482
int posx() const override
Definition: monster.h:498
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4674
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 4835 of file game.cpp.

4836{
4837 return critter_tracker->update_pos( critter, pos );
4838}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4618 of file game.cpp.

4619{
4620 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4621 add_msg( m_info, _( "You can not read a computer screen!" ) );
4622 return;
4623 }
4624 if( u.is_blind() ) {
4625 // we don't have screen readers in game
4626 add_msg( m_info, _( "You can not see a computer screen!" ) );
4627 return;
4628 }
4629 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4630 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4631 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4632 return;
4633 }
4634
4635 computer *used = m.computer_at( p );
4636
4637 if( used == nullptr ) {
4638 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4639 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4640 } else {
4641 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4642 }
4643 return;
4644 }
4645
4646 computer_session( *used ).use();
4647}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5534
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2046 of file game.cpp.

2047{
2048 basecamp camp = m.hoist_submap_camp( u.pos() );
2049 if( camp.is_valid() ) {
2050 overmap_buffer.add_camp( camp );
2052 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2053 std::string camp_name = _( "Faction Camp" );
2054 camp.set_name( camp_name );
2055 overmap_buffer.add_camp( camp );
2057 }
2058}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5565
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5560
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1988 of file game.cpp.

1989{
1990 for( auto &veh : m.get_vehicles() ) {
1991 vehicle *v = veh.v;
1994 if( other_v ) {
1995 // the other vehicle is towing us.
1996 v->tow_data.set_towing( other_v, v );
1998 }
1999 }
2000 }
2001}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:6117
towing_data tow_data
Definition: vehicle.h:1944

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 2003 of file game.cpp.

2004{
2005 for( monster &m : all_monsters() ) {
2006 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
2007 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
2008 if( !mounted_pl ) {
2009 // Target no longer valid.
2010 m.mounted_player_id = character_id();
2011 m.remove_effect( effect_ridden );
2012 continue;
2013 }
2014 mounted_pl->mounted_creature = shared_from( m );
2015 mounted_pl->setpos( m.pos() );
2016 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2017 m.mounted_player = mounted_pl;
2018 }
2019 }
2020}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2022 of file game.cpp.

2023{
2024 // Make sure visible followers are in the list.
2025 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2026 return guy.is_player_ally();
2027 } );
2028 for( npc *guy : visible_followers ) {
2029 update_faction_api( guy );
2030 add_npc_follower( guy->getID() );
2031 }
2032 // Make sure overmapbuffered NPC followers are in the list.
2033 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2034 npc *guy = temp_guy.get();
2035 if( guy->is_player_ally() ) {
2036 update_faction_api( guy );
2037 add_npc_follower( guy->getID() );
2038 }
2039 }
2040 // Make sure that serialized player followers sync up with game list
2041 for( const auto &temp_id : u.follower_ids ) {
2042 add_npc_follower( temp_id );
2043 }
2044}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1968
static void update_faction_api(npc *guy)
Definition: game.cpp:1980

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10046 of file game.cpp.

10047{
10048 if( u.is_mounted() ) {
10049 auto mons = u.mounted_creature.get();
10050 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10051 if( !mons->check_mech_powered() ) {
10052 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10053 mons->get_name() );
10054 return;
10055 }
10056 }
10057 }
10058
10059 // > and < are used for diving underwater.
10060 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10061 if( movez == -1 ) {
10062 if( u.is_underwater() ) {
10063 add_msg( m_info, _( "You are already underwater!" ) );
10064 return;
10065 }
10066 if( u.worn_with_flag( "FLOTATION" ) ) {
10067 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10068 return;
10069 }
10070 u.set_underwater( true );
10071 ///\EFFECT_STR increases breath-holding capacity while diving
10072 u.oxygen = 30 + 2 * u.str_cur;
10073 add_msg( _( "You dive underwater!" ) );
10074 } else {
10075 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10076 u.set_underwater( false );
10077 add_msg( _( "You surface." ) );
10078 } else {
10079 add_msg( m_info, _( "You try to surface but can't!" ) );
10080 }
10081 }
10082 u.moves -= 100;
10083 return;
10084 }
10085
10086 // Force means we're going down, even if there's no staircase, etc.
10087 bool climbing = false;
10088 int move_cost = 100;
10089 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10090 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10091 // Climbing
10092 if( m.has_floor_or_support( stairs ) ) {
10093 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10094 return;
10095 }
10096
10097 std::vector<tripoint> pts;
10098 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10099 if( m.passable( pt ) &&
10100 m.has_floor_or_support( pt ) ) {
10101 pts.push_back( pt );
10102 }
10103 }
10104
10105 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10106
10107 if( cost == 0 ) {
10108 if( u.has_trait( trait_WEB_ROPE ) ) {
10109 if( pts.empty() ) {
10110 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10111 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10112 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10113 add_msg( m_info, _( "You can't spin a web rope there." ) );
10114 } else if( g->m.has_furn( u.pos() ) ) {
10115 add_msg( m_info, _( "There is already furniture at that location." ) );
10116 } else {
10117 if( query_yn( "Spin a rope and climb?" ) ) {
10118 add_msg( m_good, _( "You spin a rope of web." ) );
10119 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10120 u.mod_moves( to_turns<int>( 2_seconds ) );
10122 vertical_move( movez, force, peeking );
10123 }
10124 }
10125 }
10126
10127 } else {
10128 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10129
10130 }
10131 return;
10132
10133 }
10134
10135 if( cost <= 0 || pts.empty() ) {
10136 add_msg( m_info,
10137 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10138 return;
10139 } else {
10140 // TODO: Make it an extended action
10141 climbing = true;
10142 move_cost = cost;
10143
10145 if( !pnt ) {
10146 return;
10147 }
10148 stairs = *pnt;
10149 }
10150 }
10151
10152 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10153 add_msg( m_info, _( "You can't go down here!" ) );
10154 return;
10155 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10156 add_msg( m_info, _( "You can't go up here!" ) );
10157 return;
10158 }
10159
10160 if( force ) {
10161 // Let go of a grabbed cart.
10162 u.grab( OBJECT_NONE );
10163 } else if( u.grab_point != tripoint_zero ) {
10164 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10165 return;
10166 }
10167
10168 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10169 // is called or when the map is loaded on new z-level (== false).
10170 // This caches the z-level we start the movement on (current) and the level we're want to end.
10171 const int z_before = get_levz();
10172 const int z_after = get_levz() + movez;
10173 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10174 debugmsg( "Tried to move outside allowed range of z-levels" );
10175 return;
10176 }
10177
10178 if( !u.move_effects( false ) ) {
10179 return;
10180 }
10181
10182 // Check if there are monsters are using the stairs.
10183 bool slippedpast = false;
10184 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10185 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10186 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10187 coming_to_stairs[0].name() );
10188 // Roll.
10189 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10190
10191 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10192 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10193 ///\EFFECT_STR increases chance of moving past monsters on stairs
10194
10195 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10196 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10197 if( coming_to_stairs.size() > 4 ) {
10198 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10199 dexroll /= 4;
10200 strroll /= 2;
10201 } else if( coming_to_stairs.size() > 1 ) {
10202 add_msg( m_warning, _( "There's something else behind it!" ) );
10203 dexroll /= 2;
10204 }
10205
10206 if( dexroll < 14 || strroll < 12 ) {
10208 u.moves -= 100;
10209 return;
10210 }
10211
10212 add_msg( _( "You manage to slip past!" ) );
10213 slippedpast = true;
10214 u.moves -= 100;
10215 }
10216
10217 // Shift the map up or down
10218
10219 std::unique_ptr<map> tmp_map_ptr;
10220 if( !m.has_zlevels() ) {
10221 tmp_map_ptr = std::make_unique<map>();
10222 }
10223
10224 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10225 if( m.has_zlevels() ) {
10226 // We no longer need to shift the map here! What joy
10227 } else {
10228 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10229 }
10230
10231 // Find the corresponding staircase
10232 bool rope_ladder = false;
10233 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10234 if( !force && !climbing ) {
10235 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10236 if( !pnt ) {
10237 return;
10238 }
10239 stairs = *pnt;
10240 }
10241
10242 if( !force ) {
10243 monstairz = z_before;
10244 }
10245 // Save all monsters that can reach the stairs, remove them from the tracker,
10246 // then despawn the remaining monsters. Because it's a vertical shift, all
10247 // monsters are out of the bounds of the map and will despawn.
10248 shared_ptr_fast<monster> stored_mount;
10249 if( u.is_mounted() && !m.has_zlevels() ) {
10250 // Store a *copy* of the mount, so we can remove the original monster instance
10251 // from the tracker before the map shifts.
10252 // Map shifting would otherwise just despawn the mount and would later respawn it.
10253 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10255 }
10256 if( !m.has_zlevels() ) {
10257 const tripoint to = u.pos();
10258 for( monster &critter : all_monsters() ) {
10259 // if its a ladder instead of stairs - most zombies can't climb that.
10260 // unless that have a special flag to allow them to do so.
10261 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10262 critter.has_effect( effect_ridden ) ||
10263 critter.has_effect( effect_tied ) ) {
10264 continue;
10265 }
10266 int turns = critter.turns_to_reach( to.xy() );
10267 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10268 && !slippedpast ) {
10269 critter.staircount = 10 + turns;
10270 critter.on_unload();
10271 coming_to_stairs.push_back( critter );
10272 remove_zombie( critter );
10273 }
10274 }
10275 auto mons = critter_tracker->find( g->u.pos() );
10276 if( mons != nullptr ) {
10277 critter_tracker->remove( *mons );
10278 }
10279 shift_monsters( tripoint( 0, 0, movez ) );
10280 }
10281
10282 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10283 std::vector<monster *> monsters_following;
10284 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10285 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10286 [this]( const shared_ptr_fast<npc> &np ) {
10287 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10288 rl_dist( np->pos(), u.pos() ) < 2;
10289 } );
10290 }
10291
10292 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10293 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10294 for( monster &critter : all_monsters() ) {
10295 if( ladder && !critter.climbs() ) {
10296 continue;
10297 }
10298 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10299 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10300 !critter.has_effect( effect_tied ) ) ) {
10301 monsters_following.push_back( &critter );
10302 }
10303 }
10304 }
10305
10306 if( u.is_mounted() ) {
10307 monster *crit = u.mounted_creature.get();
10308 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10309 crit->use_mech_power( -1 );
10310 if( u.movement_mode_is( CMM_WALK ) ) {
10311 crit->use_mech_power( -2 );
10312 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10313 crit->use_mech_power( -1 );
10314 } else if( u.movement_mode_is( CMM_RUN ) ) {
10315 crit->use_mech_power( -3 );
10316 }
10317 }
10318 } else {
10319 u.moves -= move_cost;
10320 }
10321 for( const auto &np : npcs_to_bring ) {
10322 if( np->in_vehicle ) {
10323 m.unboard_vehicle( np->pos() );
10324 }
10325 }
10326 const tripoint old_pos = g->u.pos();
10327 point submap_shift;
10328 vertical_shift( z_after );
10329 if( !force ) {
10330 submap_shift = update_map( stairs.x, stairs.y );
10331 }
10332
10333 // if an NPC or monster is on the stiars when player ascends/descends
10334 // they may end up merged on th esame tile, do some displacement to resolve that.
10335 // if, in the weird case of it not being possible to displace;
10336 // ( how did the player even manage to approach the stairs, if so? )
10337 // then nothing terrible happens, its just weird.
10338 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10339 std::string crit_name;
10340 bool player_displace = false;
10342 if( displace.has_value() ) {
10343 npc *guy = g->critter_at<npc>( u.pos(), true );
10344 if( guy ) {
10345 crit_name = guy->get_name();
10346 tripoint old_pos = guy->pos();
10347 if( !guy->is_enemy() ) {
10348 guy->move_away_from( u.pos(), true );
10349 if( old_pos != guy->pos() ) {
10350 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10351 }
10352 } else {
10353 player_displace = true;
10354 }
10355 }
10356 monster *mon = g->critter_at<monster>( u.pos(), true );
10357 // if the monster is ridden by the player or an NPC:
10358 // Dont displace them. If they are mounted by a friendly NPC,
10359 // then the NPC will already have been displaced just above.
10360 // if they are ridden by the player, we want them to coexist on same tile
10361 if( mon && !mon->mounted_player ) {
10362 crit_name = mon->get_name();
10363 if( mon->friendly == -1 ) {
10364 mon->setpos( *displace );
10365 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10366 } else {
10367 player_displace = true;
10368 }
10369 }
10370 if( player_displace ) {
10371 u.setpos( *displace );
10372 u.moves -= 20;
10373 add_msg( _( "You push past %s blocking the way." ), crit_name );
10374 }
10375 } else {
10376 debugmsg( "Failed to find a spot to displace into." );
10377 }
10378 }
10379
10380 // Now that we know the player's destination position, we can move their mount as well
10381 if( u.is_mounted() ) {
10382 if( stored_mount ) {
10383 assert( !m.has_zlevels() );
10384 stored_mount->spawn( g->u.pos() );
10385 if( critter_tracker->add( stored_mount ) ) {
10386 u.mounted_creature = stored_mount;
10387 }
10388 } else {
10389 u.mounted_creature->setpos( g->u.pos() );
10390 }
10391 }
10392
10393 if( !npcs_to_bring.empty() ) {
10394 // Would look nicer randomly scrambled
10395 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10396 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10397 [this]( const tripoint & c ) {
10398 return !is_empty( c );
10399 } ), candidates.end() );
10400
10401 for( const auto &np : npcs_to_bring ) {
10402 const auto found = std::find_if( candidates.begin(), candidates.end(),
10403 [this, np]( const tripoint & c ) {
10404 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10405 } );
10406 if( found != candidates.end() ) {
10407 // TODO: De-uglify
10408 np->setpos( *found );
10409 np->place_on_map();
10410 np->setpos( *found );
10411 candidates.erase( found );
10412 }
10413
10414 if( candidates.empty() ) {
10415 break;
10416 }
10417 }
10418
10419 reload_npcs();
10420 }
10421
10422 // This ugly check is here because of stair teleport bullshit
10423 // TODO: Remove stair teleport bullshit
10424 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10425 for( monster *m : monsters_following ) {
10426 m->set_dest( g->u.pos() );
10427 }
10428 }
10429
10430 if( rope_ladder ) {
10431 m.ter_set( u.pos(), t_rope_up );
10432 }
10433
10434 if( m.ter( stairs ) == t_manhole_cover ) {
10435 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10436 m.ter_set( stairs, t_manhole );
10437 }
10438
10439 // Wouldn't work and may do strange things
10440 if( u.is_hauling() && !m.has_zlevels() ) {
10441 add_msg( _( "You cannot haul items here." ) );
10442 u.stop_hauling();
10443 }
10444
10445 if( u.is_hauling() ) {
10446 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10447 start_hauling( adjusted_pos );
10448 }
10449
10450 m.invalidate_map_cache( g->get_levz() );
10451 // Upon force movement, traps can not be avoided.
10452 m.creature_on_trap( u, !force );
10453
10455}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:102
@ CMM_CROUCH
Definition: character.h:104
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1535
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:882
int oxygen
Definition: character.h:1530
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8947
std::string get_name() const override
Definition: character.cpp:6095
void start_hauling(const tripoint &pos)
Definition: game.cpp:10457
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10492
bool use_mech_power(int amt)
Definition: monster.cpp:2393
Character * mounted_player
Definition: monster.h:461
void set_underwater(bool)
Definition: player.cpp:516
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:9996
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12115
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9352
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4177

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 10679 of file game.cpp.

10680{
10681 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
10682 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
10683 return;
10684 }
10685
10686 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
10687 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
10688 z_before, z_after );
10689 return;
10690 }
10691 // Figure out where we know there are up/down connectors
10692 // Fill in all the tiles we know about (e.g. subway stations)
10693 static const int REVEAL_RADIUS = 40;
10694 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
10695 const tripoint_abs_omt cursp_before( p.xy(), z_before );
10696 const tripoint_abs_omt cursp_after( p.xy(), z_after );
10697
10698 if( !overmap_buffer.seen( cursp_before ) ) {
10699 continue;
10700 }
10701 if( overmap_buffer.has_note( cursp_after ) ) {
10702 // Already has a note -> never add an AUTO-note
10703 continue;
10704 }
10705 const oter_id &ter = overmap_buffer.ter( cursp_before );
10706 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
10707 if( z_after > z_before && ter->has_flag( known_up ) &&
10708 !ter2->has_flag( known_down ) ) {
10709 overmap_buffer.set_seen( cursp_after, true );
10710 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
10711 } else if( z_after < z_before && ter->has_flag( known_down ) &&
10712 !ter2->has_flag( known_up ) ) {
10713 overmap_buffer.set_seen( cursp_after, true );
10714 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
10715 }
10716 }
10717}
bool inbounds_z(const int z) const
Definition: map.h:1669
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 10642 of file game.cpp.

10643{
10644 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10645 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
10646 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
10647 return;
10648 }
10649
10650 // TODO: Implement dragging stuff up/down
10651 u.grab( OBJECT_NONE );
10652
10653 scent.reset();
10654
10655 u.setz( z_after );
10656 const int z_before = get_levz();
10657 if( !m.has_zlevels() ) {
10659 m.access_cache( z_before ).vehicle_list.clear();
10660 m.access_cache( z_before ).zone_vehicles.clear();
10661 m.access_cache( z_before ).map_memory_seen_cache.reset();
10662 m.set_transparency_cache_dirty( z_before );
10663 m.set_outside_cache_dirty( z_before );
10664 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
10665 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
10666 reload_npcs();
10667 } else {
10668 // Shift the map itself
10669 m.vertical_shift( z_after );
10670 }
10671
10672 m.spawn_monsters( true );
10673 // this may be required after a vertical shift if z-levels are not enabled
10674 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
10676 vertical_notes( z_before, z_after );
10677}
void setz(int z)
Definition: character.h:794
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:10679
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:410
void set_outside_cache_dirty(const int zlev)
Definition: map.h:447
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6893
std::set< vehicle * > zone_vehicles
Definition: map.h:363
std::set< vehicle * > vehicle_list
Definition: map.h:362

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 8837 of file game.cpp.

8838{
8839 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
8840 if( u.get_size() > MS_MEDIUM ) {
8841 add_msg( m_warning, _( "You can't fit there." ) );
8842 return false; // character too large to fit through a tight passage
8843 }
8844 if( u.is_mounted() ) {
8845 monster *mount = u.mounted_creature.get();
8846 if( mount->get_size() > MS_MEDIUM ) {
8847 add_msg( m_warning, _( "Your mount can't fit there." ) );
8848 return false; // char's mount is too large for tight passages
8849 }
8850 }
8851 }
8852
8853 if( u.is_mounted() ) {
8854 auto mons = u.mounted_creature.get();
8855 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
8856 if( !mons->check_mech_powered() ) {
8857 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
8858 mons->get_name() );
8859 return false;
8860 }
8861 }
8862 if( !mons->move_effects( false ) ) {
8863 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
8864 return false;
8865 }
8866 }
8867 const optional_vpart_position vp_here = m.veh_at( u.pos() );
8868 const optional_vpart_position vp_there = m.veh_at( dest_loc );
8869
8870 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
8871 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
8872 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
8873
8874 const tripoint furn_pos = u.pos() + u.grab_point;
8875 const tripoint furn_dest = dest_loc + u.grab_point;
8876
8877 bool grabbed = u.get_grab_type() != OBJECT_NONE;
8878 if( grabbed ) {
8879 const tripoint dp = dest_loc - u.pos();
8880 pushing = dp == u.grab_point;
8881 pulling = dp == -u.grab_point;
8882 }
8883 if( grabbed && dest_loc.z != u.posz() ) {
8884 add_msg( m_warning, _( "You let go of the grabbed object." ) );
8885 grabbed = false;
8886 u.grab( OBJECT_NONE );
8887 }
8888
8889 // Now make sure we're actually holding something
8890 const vehicle *grabbed_vehicle = nullptr;
8891 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
8892 // We only care about shifting, because it's the only one that can change our destination
8893 if( m.has_furn( u.pos() + u.grab_point ) ) {
8894 shifting_furniture = !pushing && !pulling;
8895 } else {
8896 // We were grabbing a furniture that isn't there
8897 grabbed = false;
8898 }
8899 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
8900 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
8901 if( grabbed_vehicle == nullptr ) {
8902 // We were grabbing a vehicle that isn't there anymore
8903 grabbed = false;
8904 }
8905 } else if( grabbed ) {
8906 // We were grabbing something WEIRD, let's pretend we weren't
8907 grabbed = false;
8908 }
8909 if( u.grab_point != tripoint_zero && !grabbed ) {
8910 add_msg( m_warning, _( "Can't find grabbed object." ) );
8911 u.grab( OBJECT_NONE );
8912 }
8913
8914 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
8915 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
8916 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8917 tripoint diff = dest_loc - u.pos();
8918 if( diff.x < 0 ) {
8919 diff.x -= 2;
8920 } else if( diff.x > 0 ) {
8921 diff.x += 2;
8922 }
8923 if( diff.y < 0 ) {
8924 diff.y -= 2;
8925 } else if( diff.y > 0 ) {
8926 diff.y += 2;
8927 }
8928 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
8929 dest_loc );
8930 }
8931 return false;
8932 }
8933 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
8934 return false;
8935 }
8936 if( u.is_mounted() && !pushing && vp_there ) {
8937 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
8938 return false;
8939 }
8940 u.set_underwater( false );
8941
8942 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
8943 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8944 if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "ALWAYS" &&
8945 !prompt_dangerous_tile( dest_loc ) ) {
8946 return true;
8947 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "RUNNING" &&
8948 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8950 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
8951 enumerate_as_string( harmful_stuff ) );
8952 return true;
8953 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "CROUCHING" &&
8954 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8956 _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ),
8957 enumerate_as_string( harmful_stuff ) );
8958 return true;
8959 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "NEVER" &&
8960 !u.movement_mode_is( CMM_RUN ) ) {
8962 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
8963 enumerate_as_string( harmful_stuff ) );
8964 return true;
8965 }
8966 }
8967 // Used to decide whether to print a 'moving is slow message
8968 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
8969
8970 int modifier = 0;
8971 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
8972 modifier = -m.furn( dest_loc ).obj().movecost;
8973 }
8974
8975 int multiplier = 1;
8976 if( u.is_on_ground() ) {
8977 multiplier *= 3;
8978 }
8979
8980 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
8981 via_ramp ) * multiplier;
8982 if( grabbed_move( dest_loc - u.pos() ) ) {
8983 return true;
8984 } else if( mcost == 0 ) {
8985 return false;
8986 }
8987 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
8988 const int previous_moves = u.moves;
8989 if( u.is_mounted() ) {
8990 auto crit = u.mounted_creature.get();
8991 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
8992 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
8993 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
8994 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
8995 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
8996 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
8997 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
8998 return false;
8999 }
9000 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
9001 const double encumb_moves = u.get_weight() / 4800.0_gram;
9002 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
9003 if( u.movement_mode_is( CMM_WALK ) ) {
9004 crit->use_mech_power( -2 );
9005 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9006 crit->use_mech_power( -1 );
9007 } else if( u.movement_mode_is( CMM_RUN ) ) {
9008 crit->use_mech_power( -3 );
9009 }
9010 } else {
9011 u.moves -= u.run_cost( mcost, diag );
9012 /**
9013 TODO:
9014 This should really use the mounted creatures stamina, if mounted.
9015 Monsters don't currently have stamina however.
9016 For the time being just don't burn players stamina when mounted.
9017 */
9018 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
9019 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
9020 u.burn_move_stamina( previous_moves - u.moves );
9021 } else {
9022 //Burn half as much stamina if vehicle has wheels, without changing move time
9023 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
9024 }
9025 }
9026 // Max out recoil & reset aim point
9029
9030 // Print a message if movement is slow
9031 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
9032 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
9033 m.has_flag_ter_or_furn( "FUNGUS",
9034 dest_loc ); //fungal furniture has no slowing effect on mycus characters
9035 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
9036 mcost_to > 4 || mcost_from > 4 ) &&
9037 !( u.has_trait( trait_M_IMMUNE ) && fungus );
9038 if( slowed && !u.is_mounted() ) {
9039 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
9040 if( mcost_to >= mcost_from ) {
9041 if( auto displayed_part = vp_there.part_displayed() ) {
9042 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9043 displayed_part->part().name() );
9044 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9045 } else {
9046 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9047 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9048 }
9049 } else {
9050 if( auto displayed_part = vp_here.part_displayed() ) {
9051 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9052 displayed_part->part().name() );
9053 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9054 } else {
9055 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9056 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9057 }
9058 }
9059 }
9060 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9061 ( !u.footwear_factor() ||
9062 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9063 // DX and IN are long suits for Cephalopods,
9064 // so this shouldn't cause too much hardship
9065 // Presumed that if it's swimmable, they're
9066 // swimming and won't stick
9067 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9068
9069 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9070 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9071 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9072 u.mod_fatigue( 1 );
9073 }
9074 }
9075 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9076 int volume = u.is_stealthy() ? 3 : 6;
9077 volume *= u.mutation_value( "noise_modifier" );
9078 if( volume > 0 ) {
9080 volume = 2;
9081 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9082 volume = 12;
9083 }
9084 if( u.movement_mode_is( CMM_RUN ) ) {
9085 volume *= 1.5;
9086 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9087 volume /= 2;
9088 }
9089 if( u.is_mounted() ) {
9090 auto mons = u.mounted_creature.get();
9091 switch( mons->get_size() ) {
9092 case MS_TINY:
9093 volume = 0; // No sound for the tinies
9094 break;
9095 case MS_SMALL:
9096 volume /= 3;
9097 break;
9098 case MS_MEDIUM:
9099 break;
9100 case MS_LARGE:
9101 volume *= 1.5;
9102 break;
9103 case MS_HUGE:
9104 volume *= 2;
9105 break;
9106 default:
9107 break;
9108 }
9109 if( mons->has_flag( MF_LOUDMOVES ) ) {
9110 volume += 6;
9111 }
9112 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9113 "none", "none" );
9114 } else {
9115 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9116 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9117 }
9119 }
9120
9121 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9122 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9123 "misc", "rattling" );
9124 }
9125 }
9126
9127 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9128 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9129 }
9130
9131 if( dest_loc != u.pos() ) {
9133 }
9134
9135 tripoint oldpos = u.pos();
9136 point submap_shift = place_player( dest_loc );
9137 point ms_shift = sm_to_ms_copy( submap_shift );
9138 oldpos = oldpos - ms_shift;
9139
9140 if( pulling ) {
9141 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9142 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9143 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9144 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9145 m.remove_field( shifted_furn_pos, fd_fire );
9146 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9147 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9148 }
9149
9150 if( u.is_hauling() ) {
9151 start_hauling( oldpos );
9152 }
9153
9155
9156 return true;
9157}
void burn_move_stamina(int moves)
Definition: character.cpp:7223
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3220
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3664
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:962
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6751
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:541
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3240
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:9763
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8766
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1835
m_size get_size() const override
Definition: monster.cpp:2693
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:596
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2199
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2514 of file game.cpp.

2515{
2516 win_screen();
2518 memorial().add(
2519 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2520 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2521 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2522 if( !u.is_dead_state() ) {
2525 }
2526}
void win_screen()
Definition: game.cpp:2528
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2528 of file game.cpp.

2529{
2530 // TODO: Move this wall somewhere
2532 std::string msg = _( "You managed to close the portal and end the invasion!" );
2533 msg += '\n';
2534 if( u.is_dead_state() ) {
2536 "Unfortunately, you had to sacrifice your life to achieve this." );
2537 msg += colorize( t, c_red ) + '\n';
2538 memorial().add(
2539 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2540 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2541 } else {
2542 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2543 msg += colorize( t, c_green ) + '\n';
2544 memorial().add(
2545 pgettext( "memorial_male", "Safely closed the portal." ),
2546 pgettext( "memorial_female", "Safely closed the portal." ) );
2547 }
2548 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2549 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2550 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2551 popup( msg );
2552}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 2917 of file game.cpp.

2918{
2919 const std::string &memorial_dir = PATH_INFO::memorialdir();
2920 const std::string &memorial_active_world_dir = memorial_dir +
2921 world_generator->active_world->world_name + "/";
2922
2923 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
2924 if( !assure_dir_exist( memorial_dir ) ) {
2925 debugmsg( "Could not make '%s' directory", memorial_dir );
2926 return;
2927 }
2928
2929 if( !assure_dir_exist( memorial_active_world_dir ) ) {
2930 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
2931 return;
2932 }
2933
2934 std::string path = memorial_active_world_dir + filename + ".txt";
2935
2936 write_to_file( path, [&]( std::ostream & fout ) {
2937 memorial().write( fout, sLastWords );
2938 }, _( "player memorial" ) );
2939}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6179 of file game.cpp.

6180{
6181 const tripoint stored_view_offset = u.view_offset;
6182
6184
6185 const int zone_ui_height = 12;
6186 const int zone_options_height = 7;
6187
6188 const int width = 45;
6189
6190 int offsetX = 0;
6191 int max_rows = 0;
6192
6193 catacurses::window w_zones;
6194 catacurses::window w_zones_border;
6195 catacurses::window w_zones_info;
6196 catacurses::window w_zones_info_border;
6197 catacurses::window w_zones_options;
6198
6199 bool show = true;
6200
6201 ui_adaptor ui;
6202 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6203 if( !show ) {
6204 ui.position( point_zero, point_zero );
6205 return;
6206 }
6207 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6208 TERMX - width : 0;
6209 const int w_zone_height = TERMY - zone_ui_height;
6210 max_rows = w_zone_height - 2;
6211 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6212 point( offsetX + 1, 1 ) );
6213 w_zones_border = catacurses::newwin( w_zone_height, width,
6214 point( offsetX, 0 ) );
6215 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6216 width - 2, point( offsetX + 1, w_zone_height ) );
6217 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6218 point( offsetX, w_zone_height ) );
6219 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6220 point( offsetX + 1, TERMY - zone_options_height ) );
6221
6222 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6223 } );
6224 ui.mark_resize();
6225
6226 std::string action;
6227 input_context ctxt( "ZONES_MANAGER" );
6228 ctxt.register_cardinal();
6229 ctxt.register_action( "CONFIRM" );
6230 ctxt.register_action( "QUIT" );
6231 ctxt.register_action( "ADD_ZONE" );
6232 ctxt.register_action( "REMOVE_ZONE" );
6233 ctxt.register_action( "MOVE_ZONE_UP" );
6234 ctxt.register_action( "MOVE_ZONE_DOWN" );
6235 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6236 ctxt.register_action( "ENABLE_ZONE" );
6237 ctxt.register_action( "DISABLE_ZONE" );
6238 ctxt.register_action( "SHOW_ALL_ZONES" );
6239 ctxt.register_action( "HELP_KEYBINDINGS" );
6240
6241 auto &mgr = zone_manager::get_manager();
6242 int start_index = 0;
6243 int active_index = 0;
6244 bool blink = false;
6245 bool stuff_changed = false;
6246 bool show_all_zones = false;
6247 int zone_cnt = 0;
6248
6249 // get zones on the same z-level, with distance between player and
6250 // zone center point <= 50 or all zones, if show_all_zones is true
6251 auto get_zones = [&]() {
6252 std::vector<zone_manager::ref_zone_data> zones;
6253 if( show_all_zones ) {
6254 zones = mgr.get_zones();
6255 } else {
6256 const tripoint &u_abs_pos = m.getabs( u.pos() );
6257 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6258 const tripoint &zone_abs_pos = ref.get().get_center_point();
6259 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6260 zones.emplace_back( ref );
6261 }
6262 }
6263 }
6264 zone_cnt = static_cast<int>( zones.size() );
6265 return zones;
6266 };
6267
6268 auto zones = get_zones();
6269
6270 auto zones_manager_options = [&]() {
6271 werase( w_zones_options );
6272
6273 if( zone_cnt > 0 ) {
6274 const auto &zone = zones[active_index].get();
6275
6276 if( zone.has_options() ) {
6277 const auto &descriptions = zone.get_options().get_descriptions();
6278
6279 // NOLINTNEXTLINE(cata-use-named-point-constants)
6280 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6281
6282 int y = 1;
6283 for( const auto &desc : descriptions ) {
6284 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6285 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6286 y++;
6287 }
6288 }
6289 }
6290
6291 wnoutrefresh( w_zones_options );
6292 };
6293
6294 cata::optional<tripoint> zone_start;
6295 cata::optional<tripoint> zone_end;
6296 bool zone_blink = false;
6297 bool zone_cursor = false;
6299 zone_start, zone_end, zone_blink, zone_cursor );
6300 add_draw_callback( zone_cb );
6301
6302 auto query_position =
6303 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6304 on_out_of_scope invalidate_current_ui( [&]()
6305 {
6306 ui.mark_resize();
6307 } );
6308 restore_on_out_of_scope<bool> show_prev( show );
6309 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6310 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6311 show = false;
6312 zone_start = cata::nullopt;
6313 zone_end = cata::nullopt;
6314 ui.mark_resize();
6315
6317 popup.on_top( true );
6318 popup.message( "%s", _( "Select first point." ) );
6319
6321
6322 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6323 false );
6324 if( first.position )
6325 {
6326 popup.message( "%s", _( "Select second point." ) );
6327
6328 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6329 true, true, false );
6330 if( second.position ) {
6331 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6332 second.position->x ),
6333 std::min( first.position->y, second.position->y ),
6334 std::min( first.position->z,
6335 second.position->z ) ) );
6336 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6337 second.position->x ),
6338 std::max( first.position->y, second.position->y ),
6339 std::max( first.position->z,
6340 second.position->z ) ) );
6341 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6342 }
6343 }
6344
6345 return cata::nullopt;
6346 };
6347
6348 ui.on_redraw( [&]( const ui_adaptor & ) {
6349 if( !show ) {
6350 return;
6351 }
6352 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6353 zones_manager_shortcuts( w_zones_info );
6354
6355 if( zone_cnt == 0 ) {
6356 werase( w_zones );
6357 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6358
6359 } else {
6360 werase( w_zones );
6361
6362 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6363
6364 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6365 wnoutrefresh( w_zones_border );
6366
6367 int iNum = 0;
6368
6369 tripoint player_absolute_pos = m.getabs( u.pos() );
6370
6371 //Display saved zones
6372 for( auto &i : zones ) {
6373 if( iNum >= start_index &&
6374 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6375 const auto &zone = i.get();
6376
6377 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6378
6379 if( iNum == active_index ) {
6380 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6381 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6382 }
6383
6384 //Draw Zone name
6385 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6386 trim_by_length( zone.get_name(), 15 ) );
6387
6388 //Draw Type name
6389 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6390 mgr.get_name_from_type( zone.get_type() ) );
6391
6392 tripoint center = zone.get_center_point();
6393
6394 //Draw direction + distance
6395 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6396 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6397 direction_name_short( direction_from( player_absolute_pos,
6398 center ) ) );
6399
6400 //Draw Vehicle Indicator
6401 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6402 zone.get_is_vehicle() ? "*" : "" );
6403 }
6404 iNum++;
6405 }
6406
6407 // Display zone options
6408 zones_manager_options();
6409 }
6410
6411 wnoutrefresh( w_zones );
6412 } );
6413
6414 zones_manager_open = true;
6415 do {
6416 if( action == "ADD_ZONE" ) {
6417 do { // not a loop, just for quick bailing out if canceled
6418 const auto maybe_id = mgr.query_type();
6419 if( !maybe_id.has_value() ) {
6420 break;
6421 }
6422
6423 const zone_type_id &id = maybe_id.value();
6424 auto options = zone_options::create( id );
6425
6426 if( !options->query_at_creation() ) {
6427 break;
6428 }
6429
6430 auto default_name = options->get_zone_name_suggestion();
6431 if( default_name.empty() ) {
6432 default_name = mgr.get_name_from_type( id );
6433 }
6434 const auto maybe_name = mgr.query_name( default_name );
6435 if( !maybe_name.has_value() ) {
6436 break;
6437 }
6438 const std::string &name = maybe_name.value();
6439
6440 const auto position = query_position();
6441 if( !position ) {
6442 break;
6443 }
6444
6445 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6446 position->second, options );
6447
6448 zones = get_zones();
6449 active_index = zone_cnt - 1;
6450
6451 stuff_changed = true;
6452 } while( false );
6453
6454 blink = false;
6455 } else if( action == "SHOW_ALL_ZONES" ) {
6456 show_all_zones = !show_all_zones;
6457 zones = get_zones();
6458 active_index = 0;
6459 } else if( zone_cnt > 0 ) {
6460 if( action == "UP" ) {
6461 active_index--;
6462 if( active_index < 0 ) {
6463 active_index = zone_cnt - 1;
6464 }
6465 blink = false;
6466 } else if( action == "DOWN" ) {
6467 active_index++;
6468 if( active_index >= zone_cnt ) {
6469 active_index = 0;
6470 }
6471 blink = false;
6472 } else if( action == "REMOVE_ZONE" ) {
6473 if( active_index < zone_cnt ) {
6474 mgr.remove( zones[active_index] );
6475 zones = get_zones();
6476 active_index--;
6477
6478 if( active_index < 0 ) {
6479 active_index = 0;
6480 }
6481 }
6482 blink = false;
6483 stuff_changed = true;
6484
6485 } else if( action == "CONFIRM" ) {
6486 auto &zone = zones[active_index].get();
6487
6488 uilist as_m;
6489 as_m.text = _( "What do you want to change:" );
6490 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6491 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6492 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6493 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6494 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6495 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6496 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6497 as_m.query();
6498
6499 switch( as_m.ret ) {
6500 case 1:
6501 if( zone.set_name() ) {
6502 stuff_changed = true;
6503 }
6504 break;
6505 case 2:
6506 if( zone.set_type() ) {
6507 stuff_changed = true;
6508 }
6509 break;
6510 case 3:
6511 if( zone.get_options().query() ) {
6512 stuff_changed = true;
6513 }
6514 break;
6515 case 4: {
6516 const auto pos = query_position();
6517 if( pos && ( pos->first != zone.get_start_point() ||
6518 pos->second != zone.get_end_point() ) ) {
6519 zone.set_position( *pos );
6520 stuff_changed = true;
6521 }
6522 break;
6523 }
6524 case 5: {
6525 on_out_of_scope invalidate_current_ui( [&]() {
6526 ui.mark_resize();
6527 } );
6528 restore_on_out_of_scope<bool> show_prev( show );
6529 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6530 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6531 show = false;
6532 zone_start = cata::nullopt;
6533 zone_end = cata::nullopt;
6534 ui.mark_resize();
6535 static_popup message_pop;
6536 message_pop.on_top( true );
6537 message_pop.message( "%s", _( "Moving zone." ) );
6538 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6539 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6540 // local position of the zone center, used to calculate the u.view_offset,
6541 // could center the screen to the position it represents
6542 auto view_center = m.getlocal( zone.get_center_point() );
6543 const look_around_result result_local = look_around( false, view_center,
6544 zone_local_start_point, false, false,
6545 false, true, zone_local_end_point );
6546 if( result_local.position ) {
6547 const auto new_start_point = m.getabs( *result_local.position );
6548 if( new_start_point == zone.get_start_point() ) {
6549 break; // Nothing changed, don't save
6550 }
6551
6552 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6553 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6554 stuff_changed = true;
6555 }
6556 }
6557 break;
6558 default:
6559 break;
6560 }
6561
6562 blink = false;
6563 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6564 if( active_index < zone_cnt - 1 ) {
6565 mgr.swap( zones[active_index], zones[active_index + 1] );
6566 zones = get_zones();
6567 active_index++;
6568 }
6569 blink = false;
6570 stuff_changed = true;
6571
6572 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6573 if( active_index > 0 ) {
6574 mgr.swap( zones[active_index], zones[active_index - 1] );
6575 zones = get_zones();
6576 active_index--;
6577 }
6578 blink = false;
6579 stuff_changed = true;
6580
6581 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6582 //show zone position on overmap;
6583 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6584 // TODO: fix point types
6585 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6586
6587 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6588 } else if( action == "ENABLE_ZONE" ) {
6589 zones[active_index].get().set_enabled( true );
6590
6591 stuff_changed = true;
6592
6593 } else if( action == "DISABLE_ZONE" ) {
6594 zones[active_index].get().set_enabled( false );
6595
6596 stuff_changed = true;
6597 }
6598 }
6599
6600 if( zone_cnt > 0 ) {
6601 blink = !blink;
6602 const auto &zone = zones[active_index].get();
6603 zone_start = m.getlocal( zone.get_start_point() );
6604 zone_end = m.getlocal( zone.get_end_point() );
6605 ctxt.set_timeout( BLINK_SPEED );
6606 } else {
6607 blink = false;
6608 zone_start = zone_end = cata::nullopt;
6609 ctxt.reset_timeout();
6610 }
6611
6612 // Actually accessed from the terrain overlay callback `zone_cb` in the
6613 // call to `ui_manager::redraw`.
6614 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6615 zone_blink = blink;
6617
6619
6620 //Wait for input
6621 action = ctxt.handle_input();
6622 } while( action != "QUIT" );
6623 zones_manager_open = false;
6624 ctxt.reset_timeout();
6625 zone_cb = nullptr;
6626
6627 if( stuff_changed ) {
6628 auto &zones = zone_manager::get_manager();
6629 if( query_yn( _( "Save changes?" ) ) ) {
6630 zones.save_zones();
6631 } else {
6632 zones.load_zones();
6633 }
6634
6635 zones.cache_data();
6636 }
6637
6638 u.view_offset = stored_view_offset;
6639}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:342
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:186
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6114
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6137
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7139 of file game.cpp.

7140{
7141#if defined(TILES)
7142 if( tileset_zoom == 64 ) {
7143 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7144 } else {
7146 }
7147 rescale_tileset( tileset_zoom );
7148#endif
7149}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7127 of file game.cpp.

7128{
7129#if defined(TILES)
7130 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7132 } else {
7133 tileset_zoom = 64;
7134 }
7135 rescale_tileset( tileset_zoom );
7136#endif
7137}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 102 of file avatar.cpp.

103{
104 return g->u;
105}

Referenced by butcher_submenu().

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12131 of file game.cpp.

12132{
12133 return *g->grid_tracker_ptr;
12134}

◆ get_map

map & get_map ( )
friend

Definition at line 144 of file map.cpp.

145{
146 return g->m;
147}

Referenced by check_art_charge_req(), extended_description(), find_empty_spot_nearby(), get_fire_fuel_string(), and print_terrain_info().

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 387 of file character.cpp.

388{
389 return g->u;
390}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 976 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1039 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1056 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1070 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1020 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1021 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1033 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 940 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1031 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1018 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 974 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1072 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 980 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 977 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1089 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1091 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1090 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1062 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1063 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1053 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1052 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 971 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 970 of file game.h.

◆ m

map& game::m

Definition at line 984 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 968 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 978 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1005 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1061 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1001 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1059 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1057 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1068 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1040 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1066 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1065 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1036 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1055 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1003 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 986 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 972 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1084 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1051 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1035 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 979 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 975 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1007 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1081 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 973 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 987 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 996 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1042 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 985 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), open_gate(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 969 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1046 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 999 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1078 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1011 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1049 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1010 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1009 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1048 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1097 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1038 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 981 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1074 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: